as-test 1.1.2 → 1.1.3

package/CHANGELOG.md

@@ -4,6 +4,9 @@
 
 - update build and run faliures to provide helpful error messages and reproduction commands and instructions
 - remove confirmation from ast clean
+- feat: make coverage gaps hierarchical and easier to scan, with parent-before-child grouping, tree-style connectors, collapsed nested gaps by default, and `--show-coverage=all` / `--verbose` expansion.
+- feat: add richer coverage point names including `DefaultValue`, `Ternary`, `IfBranch`, `Assignment`, `Loop`, `Return`, and `Throw` so uncovered points describe the actual construct instead of falling back to broad labels.
+- fix: make coverage snippets underline the emitted construct span instead of recomputing from the raw column, so cases like inline `if (...) ...` and assignments highlight the right text.
 
 ## 2026-05-12 -v1.1.1
 

package/assembly/coverage.ts

@@ -4,6 +4,10 @@ export class CoverPoint {
   public line: i32 = 0;
   public column: i32 = 0;
   public type: string = "";
+  public parentHash: string = "";
+  public scopeKind: string = "";
+  public scopeName: string = "";
+  public depth: i32 = 0;
   public executed: boolean = false;
 }
 
@@ -29,6 +33,10 @@ export function __REGISTER_RAW(
   line: i32,
   column: i32,
   type: string,
+  parentHash: string = "",
+  scopeKind: string = "",
+  scopeName: string = "",
+  depth: i32 = 0,
 ): void {
   if (Coverage.SN.allIndex.has(hash)) return;
   const point = new CoverPoint();
@@ -37,6 +45,10 @@ export function __REGISTER_RAW(
   point.line = line;
   point.column = column;
   point.type = type;
+  point.parentHash = parentHash;
+  point.scopeKind = scopeKind;
+  point.scopeName = scopeName;
+  point.depth = depth;
   Coverage.SN.points++;
   Coverage.SN.allIndex.set(hash, Coverage.SN.all.length);
   Coverage.SN.all.push(point);

package/assembly/index.ts

@@ -548,6 +548,10 @@ class CoveragePointReport {
   column: i32 = 0;
   type: string = "";
   executed: bool = false;
+  parentHash: string = "";
+  scopeKind: string = "";
+  scopeName: string = "";
+  depth: i32 = 0;
 
   serialize(): string {
     return (
@@ -563,6 +567,14 @@ class CoveragePointReport {
       quote(this.type) +
       ',"executed":' +
       (this.executed ? "true" : "false") +
+      ',"parentHash":' +
+      quote(this.parentHash) +
+      ',"scopeKind":' +
+      quote(this.scopeKind) +
+      ',"scopeName":' +
+      quote(this.scopeName) +
+      ',"depth":' +
+      this.depth.toString() +
       "}"
     );
   }
@@ -632,6 +644,10 @@ function toCoveragePointReport(point: CoverPoint): CoveragePointReport {
   out.column = point.column;
   out.type = point.type;
   out.executed = point.executed;
+  out.parentHash = point.parentHash;
+  out.scopeKind = point.scopeKind;
+  out.scopeName = point.scopeName;
+  out.depth = point.depth;
   return out;
 }
 

package/assembly/src/suite.ts

@@ -131,6 +131,8 @@ export class Suite {
       this.verdict = "ok";
     } else if (hasSkip) {
       this.verdict = "skip";
+    } else if (isTestCase) {
+      this.verdict = "ok";
     } else {
       this.verdict = "none";
     }

package/assembly/test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "as-test";
+// Import JSON and bs directly from json-as.
+// bs import prevents json-as transform from adding broken pnpm paths.
+import { JSON } from "json-as/assembly";
+
+
+@json
+class SimpleData {
+  name: string = "";
+  count: i32 = 0;
+}
+
+
+@json
+class NestedData {
+  id: string = "";
+  items: string[] = [];
+}
+
+describe("JSON", () => {
+  describe("stringify", () => {
+    it("should serialize a simple class", () => {
+      const data = new SimpleData();
+      data.name = "test";
+      data.count = 42;
+
+      const json = JSON.stringify(data);
+
+      expect(json).toBe('{"name":"test","count":42}');
+    });
+
+    it("should serialize a class with arrays", () => {
+      const data = new NestedData();
+      data.id = "abc123";
+      data.items = ["item1", "item2"];
+
+      const json = JSON.stringify(data);
+
+      expect(json).toBe('{"id":"abc123","items":["item1","item2"]}');
+    });
+
+    it("should serialize primitive types", () => {
+      expect(JSON.stringify<i32>(42)).toBe("42");
+      expect(JSON.stringify<bool>(true)).toBe("true");
+      expect(JSON.stringify<string>("hello")).toBe('"hello"');
+    });
+
+    it("should serialize arrays", () => {
+      const arr: i32[] = [1, 2, 3];
+      expect(JSON.stringify(arr)).toBe("[1,2,3]");
+    });
+  });
+
+  describe("parse", () => {
+    it("should deserialize a simple class", () => {
+      const json = '{"name":"test","count":42}';
+      const data = JSON.parse<SimpleData>(json);
+
+      expect(data.name).toBe("test");
+      expect(data.count).toBe(42);
+    });
+
+    it("should deserialize a class with arrays", () => {
+      const json = '{"id":"abc123","items":["item1","item2"]}';
+      const data = JSON.parse<NestedData>(json);
+
+      expect(data.id).toBe("abc123");
+      expect(data.items.length).toBe(2);
+      expect(data.items[0]).toBe("item1");
+      expect(data.items[1]).toBe("item2");
+    });
+
+    it("should round-trip data correctly", () => {
+      const original = new SimpleData();
+      original.name = "round-trip";
+      original.count = 123;
+
+      const json = JSON.stringify(original);
+      const restored = JSON.parse<SimpleData>(json);
+
+      expect(restored.name).toBe(original.name);
+      expect(restored.count).toBe(original.count);
+    });
+  });
+});

package/bin/commands/run-core.js

@@ -719,6 +719,8 @@ export async function run(flags = {}, configPath = DEFAULT_CONFIG_PATH, selector
             clean: cleanOutput,
             snapshotEnabled,
             showCoverage,
+            showCoverageAll: Boolean(flags.showCoverageAll),
+            verbose: Boolean(flags.verbose),
             buildTime,
             snapshotSummary,
             coverageSummary,
@@ -1204,6 +1206,10 @@ function normalizeCoverage(value) {
             column: Number(p.column ?? 0),
             type: String(p.type ?? ""),
             executed: Boolean(p.executed),
+            parentHash: String(p.parentHash ?? ""),
+            scopeKind: String(p.scopeKind ?? ""),
+            scopeName: String(p.scopeName ?? ""),
+            depth: Number(p.depth ?? 0),
         };
     })
         .filter((point) => point.file.length > 0);
@@ -1475,10 +1481,14 @@ function matchesCoverageTextPattern(value, pattern) {
     return globPatternToRegExp(normalized).test(value);
 }
 function compareCoveragePoints(a, b) {
+    const depthA = a.depth ?? 0;
+    const depthB = b.depth ?? 0;
     if (a.line !== b.line)
         return a.line - b.line;
     if (a.column !== b.column)
         return a.column - b.column;
+    if (depthA !== depthB)
+        return depthA - depthB;
     if (a.type !== b.type)
         return a.type.localeCompare(b.type);
     return a.hash.localeCompare(b.hash);

package/bin/commands/run.js

@@ -4,12 +4,14 @@ export async function executeRunCommand(rawArgs, flags, configPath, selectedMode
     const suiteSelectors = deps.resolveSuiteSelectors(rawArgs, "run");
     const listFlags = deps.resolveListFlags(rawArgs, "run");
     const featureToggles = deps.resolveFeatureToggles(rawArgs, "run");
+    const showCoverageMode = deps.resolveShowCoverageMode(rawArgs, "run");
     const runFlags = {
         snapshot: !flags.includes("--no-snapshot"),
         createSnapshots: flags.includes("--create-snapshots"),
         overwriteSnapshots: flags.includes("--overwrite-snapshots"),
         clean: flags.includes("--clean"),
-        showCoverage: flags.includes("--show-coverage"),
+        showCoverage: showCoverageMode != undefined,
+        showCoverageAll: showCoverageMode == "all",
         verbose: flags.includes("--verbose"),
         ...deps.resolveParallelJobs(rawArgs, "run"),
         coverage: featureToggles.coverage,

package/bin/commands/test.js

@@ -8,12 +8,14 @@ export async function executeTestCommand(rawArgs, flags, configPath, selectedMod
         tryAs: featureToggles.tryAs,
         coverage: featureToggles.coverage,
     };
+    const showCoverageMode = deps.resolveShowCoverageMode(rawArgs, "test");
     const runFlags = {
         snapshot: !flags.includes("--no-snapshot"),
         createSnapshots: flags.includes("--create-snapshots"),
         overwriteSnapshots: flags.includes("--overwrite-snapshots"),
         clean: flags.includes("--clean"),
-        showCoverage: flags.includes("--show-coverage"),
+        showCoverage: showCoverageMode != undefined,
+        showCoverageAll: showCoverageMode == "all",
         verbose: flags.includes("--verbose"),
         ...deps.resolveParallelJobs(rawArgs, "test"),
         coverage: featureToggles.coverage,

package/bin/coverage-points.js

@@ -13,7 +13,61 @@ export function describeCoveragePoint(file, line, column, fallbackType) {
             highlightEnd: 0,
         };
     }
-    const declaration = detectCoverageDeclaration(context.visible);
+    const parameter = detectCoverageParameter(context.visible, context.focus, fallbackType);
+    if (parameter) {
+        return {
+            displayType: parameter.type,
+            subjectName: parameter.name,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: parameter.start,
+            highlightEnd: parameter.end,
+        };
+    }
+    const ternary = detectCoverageTernary(context.visible, context.focus, fallbackType);
+    if (ternary) {
+        return {
+            displayType: ternary.type,
+            subjectName: null,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: ternary.start,
+            highlightEnd: ternary.end,
+        };
+    }
+    const ifBranch = detectCoverageIfBranch(context.visible, fallbackType);
+    if (ifBranch) {
+        return {
+            displayType: ifBranch.type,
+            subjectName: null,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: ifBranch.start,
+            highlightEnd: ifBranch.end,
+        };
+    }
+    const assignment = detectCoverageAssignment(context.visible, fallbackType);
+    if (assignment) {
+        return {
+            displayType: assignment.type,
+            subjectName: null,
+            visible: context.visible,
+            focus: context.focus,
+            highlightStart: assignment.start,
+            highlightEnd: assignment.end,
+        };
+    }
+    const declarationAllowed = fallbackType == "Expression" ||
+        fallbackType == "Block" ||
+        fallbackType == "Function" ||
+        fallbackType == "Method" ||
+        fallbackType == "Constructor" ||
+        fallbackType == "Variable" ||
+        fallbackType == "Property" ||
+        fallbackType == "Call";
+    const declaration = declarationAllowed
+        ? detectCoverageDeclaration(context.visible)
+        : null;
     if (declaration) {
         const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(context.visible, context.focus);
         return {
@@ -25,7 +79,10 @@ export function describeCoveragePoint(file, line, column, fallbackType) {
             highlightEnd,
         };
     }
-    const call = detectCoverageCall(context.visible, context.focus);
+    const callAllowed = fallbackType == "Expression" || fallbackType == "Call";
+    const call = callAllowed
+        ? detectCoverageCall(context.visible, context.focus)
+        : null;
     if (call) {
         return {
             displayType: "Call",
@@ -130,6 +187,147 @@ function detectCoverageDeclaration(visible) {
     }
     return null;
 }
+function detectCoverageParameter(visible, focus, fallbackType) {
+    const inlineParameter = detectCoverageInlineParameter(visible, focus, fallbackType);
+    if (inlineParameter) {
+        return inlineParameter;
+    }
+    const openParen = visible.indexOf("(");
+    const closeParen = visible.lastIndexOf(")");
+    if (openParen == -1 || closeParen == -1 || closeParen <= openParen) {
+        return null;
+    }
+    if (focus <= openParen || focus >= closeParen) {
+        return null;
+    }
+    const params = visible.slice(openParen + 1, closeParen);
+    const matches = [
+        ...params.matchAll(/([A-Za-z_]\w*)\s*:\s*[^,)=]+(?:=\s*[^,)]*)?/g),
+    ];
+    if (!matches.length)
+        return null;
+    for (const match of matches) {
+        const localStart = match.index ?? -1;
+        if (localStart == -1)
+            continue;
+        const localEnd = localStart + match[0].length;
+        const absoluteStart = openParen + 1 + localStart;
+        const absoluteEnd = openParen + 1 + localEnd;
+        if (focus < absoluteStart || focus > absoluteEnd)
+            continue;
+        const name = match[1] ?? null;
+        if (!name)
+            return null;
+        const nameOffset = match[0].indexOf(name);
+        const equalsOffset = match[0].indexOf("=");
+        if (fallbackType == "DefaultValue" && equalsOffset != -1) {
+            const valueStart = absoluteStart + equalsOffset + 1;
+            const valueVisibleStart = skipCoverageWhitespace(visible, valueStart);
+            const [start, end] = resolveCoverageHighlightSpan(visible, Math.max(valueVisibleStart, focus));
+            return {
+                type: "DefaultValue",
+                name,
+                start,
+                end,
+            };
+        }
+        return {
+            type: fallbackType == "Parameter" ? "Parameter" : "Property",
+            name,
+            start: absoluteStart + nameOffset,
+            end: absoluteStart + nameOffset + name.length,
+        };
+    }
+    return null;
+}
+function detectCoverageInlineParameter(visible, focus, fallbackType) {
+    const match = visible.match(/^([A-Za-z_]\w*)\s*:\s*[^=,]+(?:=\s*[^,]+)?[,]?$/);
+    if (!match)
+        return null;
+    const name = match[1] ?? null;
+    if (!name)
+        return null;
+    const nameStart = visible.indexOf(name);
+    const nameEnd = nameStart + name.length;
+    const equalsIndex = visible.indexOf("=");
+    if (fallbackType == "DefaultValue" && equalsIndex != -1) {
+        const valueStart = skipCoverageWhitespace(visible, equalsIndex + 1);
+        const [start, end] = resolveCoverageHighlightSpan(visible, Math.max(valueStart, focus));
+        return {
+            type: "DefaultValue",
+            name,
+            start,
+            end,
+        };
+    }
+    return {
+        type: fallbackType == "Parameter" ? "Parameter" : "Property",
+        name,
+        start: nameStart,
+        end: nameEnd,
+    };
+}
+function detectCoverageTernary(visible, focus, fallbackType) {
+    if (fallbackType != "Ternary" && fallbackType != "LogicalBranch") {
+        return null;
+    }
+    const q = visible.indexOf("?");
+    if (q == -1)
+        return null;
+    if (fallbackType == "LogicalBranch") {
+        const [start, end] = resolveCoverageHighlightSpan(visible, focus);
+        return { type: "LogicalBranch", start, end };
+    }
+    const colon = visible.indexOf(":", q + 1);
+    if (colon == -1) {
+        const [start, end] = resolveCoverageHighlightSpan(visible, focus);
+        return { type: "Ternary", start, end };
+    }
+    const branchStart = focus <= colon ? q + 1 : colon + 1;
+    const normalizedStart = skipCoverageWhitespace(visible, branchStart);
+    const [start, end] = resolveCoverageHighlightSpan(visible, Math.max(normalizedStart, focus));
+    return { type: "Ternary", start, end };
+}
+function detectCoverageIfBranch(visible, fallbackType) {
+    if (fallbackType != "IfBranch")
+        return null;
+    const match = visible.match(/^if\s*\(([^)]*)\)/);
+    if (!match)
+        return null;
+    const full = match[0];
+    const condition = match[1] ?? "";
+    const openParen = full.indexOf("(");
+    const conditionPadding = condition.length
+        ? condition.length - condition.trimStart().length
+        : 0;
+    const conditionStart = openParen == -1 ? -1 : openParen + 1 + conditionPadding;
+    if (conditionStart == -1 || !condition.length) {
+        return { type: "IfBranch", start: 0, end: full.length };
+    }
+    return {
+        type: "IfBranch",
+        start: conditionStart,
+        end: conditionStart + condition.length,
+    };
+}
+function detectCoverageAssignment(visible, fallbackType) {
+    if (fallbackType != "Assignment")
+        return null;
+    const match = visible.match(/([A-Za-z_]\w*(?:\.[A-Za-z_]\w*|\[[^\]]+\])?)\s*(=|\+=|-=|\*=|\*\*=|\/=|%=|<<=|>>=|>>>=|&=|\|=|\^=)/);
+    if (!match)
+        return null;
+    const full = match[0];
+    const lhs = match[1] ?? "";
+    const operator = match[2] ?? "=";
+    const fullStart = visible.indexOf(full);
+    const lhsStart = fullStart + full.indexOf(lhs);
+    const operatorStart = fullStart + full.lastIndexOf(operator);
+    return {
+        type: "Assignment",
+        start: lhsStart,
+        end: operatorStart + operator.length,
+    };
+}
 function detectCoverageCall(visible, focus) {
     const matches = [...visible.matchAll(/\b([A-Za-z_]\w*)(?:<[^>()]+>)?\s*\(/g)];
     if (!matches.length)
@@ -171,3 +369,10 @@ function detectCoverageCall(visible, focus) {
 function isCoverageBoundary(ch) {
     return /[\s()[\]{}.,;:+\-*/%&|^!?=<>]/.test(ch);
 }
+function skipCoverageWhitespace(visible, index) {
+    let current = Math.max(0, Math.min(visible.length - 1, index));
+    while (current < visible.length - 1 && /\s/.test(visible.charAt(current))) {
+        current++;
+    }
+    return current;
+}

package/bin/index.js

@@ -78,6 +78,7 @@ else if (COMMANDS.includes(args[0])) {
                 resolveParallelJobs,
                 resolveBrowserOverride,
                 resolveReporterOverride,
+                resolveShowCoverageMode,
                 resolveExecutionModes,
                 listExecutionPlan,
                 runRuntimeModes,
@@ -96,6 +97,7 @@ else if (COMMANDS.includes(args[0])) {
                 resolveParallelJobs,
                 resolveBrowserOverride,
                 resolveReporterOverride,
+                resolveShowCoverageMode,
                 resolveFuzzOverrides,
                 resolveExecutionModes,
                 listExecutionPlan,
@@ -277,7 +279,7 @@ function printCommandHelp(command) {
         process.stdout.write("  --create-snapshots       Create missing snapshot entries\n");
         process.stdout.write("  --overwrite-snapshots    Overwrite existing snapshot entries on mismatch\n");
         process.stdout.write("  --no-snapshot            Disable snapshot assertions for this run\n");
-        process.stdout.write("  --show-coverage          Print uncovered coverage point details\n");
+        process.stdout.write("  --show-coverage[=all]    Print uncovered coverage point details; use =all to expand nested gaps\n");
         process.stdout.write("  --suite <name[,name...]> Filter results to matching suite names or suite slug paths\n");
         process.stdout.write("  --suites <name[,name...]> Alias for --suite\n");
         process.stdout.write("  --enable <feature>       Enable feature (coverage|try-as)\n");
@@ -305,7 +307,7 @@ function printCommandHelp(command) {
         process.stdout.write("  --create-snapshots       Create missing snapshot entries\n");
         process.stdout.write("  --overwrite-snapshots    Overwrite existing snapshot entries on mismatch\n");
         process.stdout.write("  --no-snapshot            Disable snapshot assertions for this run\n");
-        process.stdout.write("  --show-coverage          Print uncovered coverage point details\n");
+        process.stdout.write("  --show-coverage[=all]    Print uncovered coverage point details; use =all to expand nested gaps\n");
         process.stdout.write("  --suite <name[,name...]> Filter results to matching suite names or suite slug paths\n");
         process.stdout.write("  --suites <name[,name...]> Alias for --suite\n");
         process.stdout.write("  --enable <feature>       Enable feature (coverage|try-as)\n");
@@ -462,8 +464,15 @@ function resolveCommandArgs(rawArgs, command) {
             arg == "--build-jobs" ||
             arg == "--run-jobs" ||
             arg == "--browser" ||
+            arg == "--show-coverage" ||
             arg == "--fuzz-runs" ||
             arg == "--fuzz-seed") {
+            if (arg == "--show-coverage") {
+                const next = rawArgs[i + 1];
+                if (next == "all")
+                    i++;
+                continue;
+            }
             i++;
             continue;
         }
@@ -476,6 +485,7 @@ function resolveCommandArgs(rawArgs, command) {
             arg.startsWith("--build-jobs=") ||
             arg.startsWith("--run-jobs=") ||
             arg.startsWith("--browser=") ||
+            arg.startsWith("--show-coverage=") ||
             arg.startsWith("--fuzz-runs=") ||
             arg.startsWith("--fuzz-seed=")) {
             continue;
@@ -762,6 +772,34 @@ function resolveReporterOverride(rawArgs, command) {
     }
     return undefined;
 }
+function resolveShowCoverageMode(rawArgs, command) {
+    let seenCommand = false;
+    for (let i = 0; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+        if (!seenCommand) {
+            if (arg == command)
+                seenCommand = true;
+            continue;
+        }
+        if (arg == "--show-coverage") {
+            const next = rawArgs[i + 1];
+            if (next == "all")
+                return "all";
+            return "collapsed";
+        }
+        if (arg.startsWith("--show-coverage=")) {
+            const value = arg.slice("--show-coverage=".length).trim();
+            if (!value.length) {
+                throw new Error("--show-coverage requires a value when using =");
+            }
+            if (value != "all") {
+                throw new Error(`--show-coverage only supports "all" when given a value`);
+            }
+            return "all";
+        }
+    }
+    return undefined;
+}
 function resolveJobs(rawArgs, command) {
     let seenCommand = false;
     let parallel = false;
@@ -1140,6 +1178,8 @@ async function runTestSequential(runFlags, configPath, selectors, suiteSelectors
             clean: runFlags.clean,
             snapshotEnabled,
             showCoverage: runFlags.showCoverage,
+            showCoverageAll: runFlags.showCoverageAll,
+            verbose: runFlags.verbose,
             buildTime: getMergedIntervalDuration(buildIntervals),
             snapshotSummary: summary.snapshotSummary,
             coverageSummary: summary.coverageSummary,
@@ -1372,6 +1412,8 @@ async function runRuntimeMatrix(runFlags, configPath, selectors, suiteSelectors,
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: 0,
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -1435,6 +1477,8 @@ async function runTestModes(runFlags, configPath, selectors, suiteSelectors, fuz
                     clean: runFlags.clean,
                     snapshotEnabled: effectiveRunFlags.snapshot !== false,
                     showCoverage: effectiveRunFlags.showCoverage,
+                    showCoverageAll: effectiveRunFlags.showCoverageAll,
+                    verbose: effectiveRunFlags.verbose,
                     buildTime: modeResult.summary.buildTime +
                         getMergedIntervalDuration(collectFuzzBuildIntervals(fuzzResults)),
                     snapshotSummary: modeResult.summary.snapshotSummary,
@@ -1572,6 +1616,8 @@ async function runTestMatrix(runFlags, configPath, selectors, suiteSelectors, fu
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: getMergedIntervalDuration(buildIntervals),
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -1664,6 +1710,8 @@ async function runRuntimeSingleParallel(runFlags, configPath, selectors, suiteSe
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: 0,
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -1778,6 +1826,8 @@ async function runRuntimeMatrixParallel(runFlags, configPath, selectors, suiteSe
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: getMergedIntervalDuration(buildIntervals),
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -1880,6 +1930,8 @@ async function runTestSingleParallel(runFlags, configPath, selectors, suiteSelec
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: getMergedIntervalDuration(buildIntervals),
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,
@@ -2013,6 +2065,8 @@ async function runTestMatrixParallel(runFlags, configPath, selectors, suiteSelec
         clean: runFlags.clean,
         snapshotEnabled,
         showCoverage: runFlags.showCoverage,
+        showCoverageAll: runFlags.showCoverageAll,
+        verbose: runFlags.verbose,
         buildTime: getMergedIntervalDuration(buildIntervals),
         snapshotSummary: summary.snapshotSummary,
         coverageSummary: summary.coverageSummary,

package/bin/reporters/default.js

@@ -3,7 +3,7 @@ import { diff } from "typer-diff";
 import { readFileSync } from "fs";
 import * as path from "path";
 import { formatSpecDisplayPath, formatTime } from "../util.js";
-import { describeCoveragePoint, readCoverageSourceLine, resolveCoverageHighlightSpan, } from "../coverage-points.js";
+import { describeCoveragePoint } from "../coverage-points.js";
 export const createReporter = (context) => {
     return new DefaultReporter(context);
 };
@@ -288,7 +288,7 @@ class DefaultReporter {
         if (event.coverageSummary.enabled) {
             renderCoverageSummary(event.coverageSummary, event.showCoverage);
             if (event.showCoverage && event.coverageSummary.uncovered) {
-                renderCoveragePoints(event.coverageSummary.files);
+                renderCoveragePoints(event.coverageSummary.files, Boolean(event.verbose || event.showCoverageAll));
             }
         }
         renderTotals(event.stats, event);
@@ -831,7 +831,7 @@ function renderCoverageSummary(summary, showCoverage) {
         console.log(chalk.dim(`    ... ${ranked.length - 8} more files`));
     }
 }
-function renderCoveragePoints(files) {
+function renderCoveragePoints(files, expandNested) {
     console.log("");
     console.log(chalk.bold("Coverage Gaps"));
     const sortedFiles = [...files].sort((a, b) => a.file.localeCompare(b.file));
@@ -842,28 +842,124 @@ function renderCoveragePoints(files) {
         displayType: describeCoveragePoint(point.file, point.line, point.column, point.type).displayType,
     })));
     const layout = createCoverageGapLayout(missingPoints);
+    let renderedFileCount = 0;
+    let collapsedNestedPoints = 0;
     for (const file of sortedFiles) {
-        const points = [...file.points].sort((a, b) => {
-            if (a.line != b.line)
-                return a.line - b.line;
-            if (a.column != b.column)
-                return a.column - b.column;
-            return a.type.localeCompare(b.type);
-        });
+        const points = [...file.points].sort(compareCoverageGapPoints);
         const missing = points.filter((point) => !point.executed);
         if (!missing.length)
             continue;
+        if (renderedFileCount > 0) {
+            console.log("");
+        }
         console.log(`  ${chalk.bold(toRelativeResultPath(file.file))} ${chalk.dim(`(${missing.length} uncovered)`)}`);
+        const pointsByHash = new Map(points.map((point) => [point.hash, point]));
+        const childrenByParent = new Map();
+        const roots = [];
         for (const point of points) {
-            if (point.executed)
-                continue;
-            const location = `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`;
-            const snippet = formatCoverageSnippet(point.file, point.line, point.column);
-            const typeLabel = describeCoveragePoint(point.file, point.line, point.column, point.type).displayType.padEnd(layout.typeWidth + 4);
-            const locationLabel = location.padEnd(layout.locationWidth + 4);
-            console.log(`    ${chalk.red("x")} ${chalk.dim(typeLabel)}${chalk.dim(locationLabel)}${snippet}`);
+            const parentHash = point.parentHash ?? "";
+            if (parentHash.length && pointsByHash.has(parentHash)) {
+                const children = childrenByParent.get(parentHash) ?? [];
+                children.push(point);
+                childrenByParent.set(parentHash, children);
+            }
+            else {
+                roots.push(point);
+            }
+        }
+        const visibleRoots = roots.filter((point) => shouldRenderCoveragePoint(point, childrenByParent));
+        for (let i = 0; i < visibleRoots.length; i++) {
+            collapsedNestedPoints += renderCoveragePointTree(visibleRoots[i], childrenByParent, layout, [], i == visibleRoots.length - 1, expandNested);
         }
+        renderedFileCount++;
     }
+    if (!expandNested && collapsedNestedPoints > 0) {
+        console.log("");
+        console.log(chalk.dim("  Run with --show-coverage=all or --verbose to expand nested coverage gaps."));
+    }
+}
+function renderCoveragePointTree(point, childrenByParent, layout, ancestorHasNext, isLast, expandNested) {
+    const visibleChildren = [...(childrenByParent.get(point.hash) ?? [])]
+        .filter((child) => shouldRenderCoveragePoint(child, childrenByParent))
+        .sort(compareCoverageGapPoints);
+    const nestedUncoveredCount = countNestedUncoveredPoints(visibleChildren, childrenByParent);
+    if (!point.executed) {
+        renderCoverageGapLine(point, layout, ancestorHasNext, isLast);
+        if (nestedUncoveredCount > 0) {
+            if (expandNested) {
+                let rendered = 0;
+                for (let i = 0; i < visibleChildren.length; i++) {
+                    rendered += renderCoveragePointTree(visibleChildren[i], childrenByParent, layout, [...ancestorHasNext, !isLast], i == visibleChildren.length - 1, expandNested);
+                }
+                return 1 + rendered;
+            }
+            const treePrefix = buildCoverageTreePrefix([...ancestorHasNext, !isLast], true);
+            console.log(`    ${treePrefix}${chalk.dim(`(+${nestedUncoveredCount} nested uncovered point${nestedUncoveredCount == 1 ? "" : "s"})`)}`);
+            return nestedUncoveredCount;
+        }
+        return 0;
+    }
+    if (nestedUncoveredCount <= 0)
+        return 0;
+    renderCoverageScopeHeader(point, layout, ancestorHasNext, isLast);
+    let rendered = 0;
+    for (let i = 0; i < visibleChildren.length; i++) {
+        rendered += renderCoveragePointTree(visibleChildren[i], childrenByParent, layout, [...ancestorHasNext, !isLast], i == visibleChildren.length - 1, expandNested);
+    }
+    return rendered;
+}
+function shouldRenderCoveragePoint(point, childrenByParent) {
+    if (!point.executed)
+        return true;
+    return (countNestedUncoveredPoints(childrenByParent.get(point.hash) ?? [], childrenByParent) > 0);
+}
+function countNestedUncoveredPoints(points, childrenByParent) {
+    let count = 0;
+    for (const point of points) {
+        if (!point.executed)
+            count++;
+        count += countNestedUncoveredPoints(childrenByParent.get(point.hash) ?? [], childrenByParent);
+    }
+    return count;
+}
+function renderCoverageGapLine(point, layout, ancestorHasNext, isLast) {
+    const location = `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`;
+    const snippet = formatCoverageSnippet(point.file, point.line, point.column, point.type, ancestorHasNext.length);
+    const typeLabel = describeCoveragePoint(point.file, point.line, point.column, point.type).displayType.padEnd(layout.typeWidth + 6);
+    const locationLabel = location.padEnd(layout.locationWidth + 6);
+    const treePrefix = buildCoverageTreePrefix(ancestorHasNext, isLast);
+    const meta = `${typeLabel}${locationLabel}`;
+    console.log(`    ${treePrefix}${chalk.dim(meta)}  ${snippet}`);
+}
+function renderCoverageScopeHeader(point, layout, ancestorHasNext, isLast) {
+    const descriptor = describeCoveragePoint(point.file, point.line, point.column, point.type);
+    const label = point.scopeKind || descriptor.displayType;
+    const location = `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`;
+    const locationLabel = location.padEnd(layout.locationWidth + 6);
+    const typeLabel = label.padEnd(layout.typeWidth + 6);
+    const snippet = formatCoverageSnippet(point.file, point.line, point.column, point.type, ancestorHasNext.length);
+    const treePrefix = buildCoverageTreePrefix(ancestorHasNext, isLast);
+    const meta = `${typeLabel}${locationLabel}`;
+    console.log(`    ${treePrefix}${chalk.dim(meta)}  ${chalk.dim(snippet)}`);
+}
+function buildCoverageTreePrefix(ancestorHasNext, isLast) {
+    let out = "";
+    for (const hasNext of ancestorHasNext) {
+        out += hasNext ? "│ " : "  ";
+    }
+    out += isLast ? "└─" : "├─";
+    return chalk.dim(out);
+}
+function compareCoverageGapPoints(a, b) {
+    if (a.line != b.line)
+        return a.line - b.line;
+    if (a.column != b.column)
+        return a.column - b.column;
+    if ((a.depth ?? 0) != (b.depth ?? 0))
+        return (a.depth ?? 0) - (b.depth ?? 0);
+    if (a.type != b.type)
+        return a.type.localeCompare(b.type);
+    return a.hash.localeCompare(b.hash);
 }
 function renderCoverageBar(percent) {
     const slots = 12;
@@ -877,32 +973,25 @@ function createCoverageGapLayout(points) {
             .length), 1),
     };
 }
-function formatCoverageSnippet(file, line, column) {
-    const sourceLine = readCoverageSourceLine(file, line);
-    if (!sourceLine)
-        return "";
-    const expanded = sourceLine.replace(/\t/g, "  ");
-    const firstNonWhitespace = expanded.search(/\S/);
-    if (firstNonWhitespace == -1)
-        return "";
-    const visible = expanded.slice(firstNonWhitespace).trimEnd();
+function formatCoverageSnippet(file, line, column, fallbackType, _depth) {
+    const descriptor = describeCoveragePoint(file, line, column, fallbackType);
+    const visible = descriptor.visible;
     if (!visible.length)
         return "";
     const maxWidth = 72;
-    const focus = Math.max(0, Math.min(visible.length - 1, Math.max(0, column - 1 - firstNonWhitespace)));
+    const focus = Math.max(0, Math.min(visible.length - 1, descriptor.focus));
     if (visible.length <= maxWidth) {
-        return styleCoverageSnippetWindow(visible, 0, visible.length, focus);
+        return styleCoverageSnippetWindow(visible, 0, visible.length, focus, descriptor.highlightStart, descriptor.highlightEnd);
     }
     const start = Math.max(0, Math.min(visible.length - maxWidth, focus - Math.floor(maxWidth / 2)));
     const end = Math.min(visible.length, start + maxWidth);
-    return styleCoverageSnippetWindow(visible, start, end, focus);
+    return styleCoverageSnippetWindow(visible, start, end, focus, descriptor.highlightStart, descriptor.highlightEnd);
 }
-function styleCoverageSnippetWindow(visible, start, end, focus) {
+function styleCoverageSnippetWindow(visible, start, end, focus, highlightStart, highlightEnd) {
     const prefix = start > 0 ? "..." : "";
     const suffix = end < visible.length ? "..." : "";
     const slice = visible.slice(start, end);
     const localFocus = Math.max(0, Math.min(slice.length - 1, focus - start));
-    const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(visible, focus);
     const localStart = Math.max(0, Math.min(slice.length, highlightStart - start));
     const localEnd = Math.max(localStart + 1, Math.min(slice.length, highlightEnd - start));
     if (!slice.length)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "as-test",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -20,6 +20,7 @@
     "as-test": "./",
     "assemblyscript": "^0.28.17",
     "assemblyscript-prettier": "^3.0.4",
+    "json-as": "^1.3.5",
     "prettier": "3.8.3",
     "try-as": "^1.0.1",
     "typescript": "^6.0.3",

package/transform/lib/coverage.js

@@ -2,12 +2,6 @@ import { BlockStatement, ExpressionStatement, Node, } from "assemblyscript/dist/
 import { RangeTransform } from "./range.js";
 import { isStdlib, SimpleParser } from "./util.js";
 import { Visitor } from "./visitor.js";
-var CoverType;
-(function (CoverType) {
-    CoverType[CoverType["Function"] = 0] = "Function";
-    CoverType[CoverType["Expression"] = 1] = "Expression";
-    CoverType[CoverType["Block"] = 2] = "Block";
-})(CoverType || (CoverType = {}));
 const COVERAGE_IGNORED_CALLS = new Set([
     "beforeAll",
     "afterAll",
@@ -50,13 +44,106 @@ class CoverPoint {
     hash = "";
     line = 0;
     column = 0;
-    type;
+    type = "Expression";
     executed = false;
+    parentHash = "";
+    scopeKind = "";
+    scopeName = "";
+    depth = 0;
 }
 export class CoverageTransform extends Visitor {
     mustImport = false;
     points = new Map();
     globalStatements = [];
+    scopeStack = [];
+    getCurrentScope() {
+        return this.scopeStack.length
+            ? this.scopeStack[this.scopeStack.length - 1]
+            : null;
+    }
+    withScope(point, callback) {
+        this.scopeStack.push(point);
+        try {
+            callback();
+        }
+        finally {
+            this.scopeStack.pop();
+        }
+    }
+    assignParentMetadata(point) {
+        const currentScope = this.getCurrentScope();
+        if (!currentScope)
+            return;
+        point.parentHash = currentScope.hash;
+        point.scopeKind = currentScope.scopeKind;
+        point.scopeName = currentScope.scopeName;
+        point.depth = currentScope.depth + 1;
+    }
+    assignScopeMetadata(point, scopeKind, scopeName = null) {
+        point.scopeKind = scopeKind;
+        point.scopeName = scopeName ?? "";
+    }
+    createFunctionPoint(path, node, scopeKind, scopeName = null) {
+        const funcLc = getLineCol(node);
+        const point = new CoverPoint();
+        point.line = funcLc?.line;
+        point.column = funcLc?.column;
+        point.file = path;
+        point.type = scopeKind;
+        this.assignParentMetadata(point);
+        this.assignScopeMetadata(point, scopeKind, scopeName);
+        point.hash = hash(point);
+        return point;
+    }
+    createPoint(path, node, type) {
+        const lc = getLineCol(node);
+        const point = new CoverPoint();
+        point.line = lc?.line;
+        point.column = lc?.column;
+        point.file = path;
+        point.type = type;
+        this.assignParentMetadata(point);
+        point.hash = hash(point);
+        return point;
+    }
+    instrumentStatementBody(path, node, type) {
+        const point = this.createPoint(path, node, type);
+        const replacer = new RangeTransform(node);
+        const registerStmt = createRegisterStatement(point);
+        replacer.visit(registerStmt);
+        const coverStmt = createCoverStatement(point.hash, node);
+        replacer.visit(coverStmt);
+        this.globalStatements.push(registerStmt);
+        if (node.kind == 31) {
+            const block = node;
+            block.statements.unshift(coverStmt);
+            return block;
+        }
+        const coverBlock = Node.createBlockStatement([coverStmt], node.range);
+        replacer.visit(coverBlock);
+        coverBlock.statements.push(node);
+        return coverBlock;
+    }
+    isAssignmentOperator(operator) {
+        switch (operator) {
+            case 101:
+            case 102:
+            case 103:
+            case 104:
+            case 105:
+            case 106:
+            case 107:
+            case 108:
+            case 109:
+            case 110:
+            case 111:
+            case 112:
+            case 113:
+                return true;
+            default:
+                return false;
+        }
+    }
     visitCallExpression(node) {
         const callName = getCallName(node);
         if (callName && COVERAGE_IGNORED_CALLS.has(callName)) {
@@ -89,7 +176,8 @@ export class CoverageTransform extends Visitor {
                 point.line = rightLc?.line;
                 point.column = rightLc?.column;
                 point.file = path;
-                point.type = CoverType.Expression;
+                point.type = "LogicalBranch";
+                this.assignParentMetadata(point);
                 point.hash = hash(point);
                 const replacer = new RangeTransform(node);
                 const registerStmt = createRegisterStatement(point);
@@ -100,10 +188,25 @@ export class CoverageTransform extends Visitor {
                 this.globalStatements.push(registerStmt);
                 break;
             }
+            default: {
+                if (!this.isAssignmentOperator(node.operator))
+                    break;
+                const right = node.right;
+                if (isBuiltinCallExpression(right))
+                    break;
+                const point = this.createPoint(path, right, "Assignment");
+                const replacer = new RangeTransform(node);
+                const registerStmt = createRegisterStatement(point);
+                replacer.visit(registerStmt);
+                const coverExpression = createCoverExpression(point.hash, right, node);
+                replacer.visit(coverExpression);
+                node.right = coverExpression;
+                this.globalStatements.push(registerStmt);
+                break;
+            }
         }
     }
     visitMethodDeclaration(node) {
-        super.visitMethodDeclaration(node);
         if (node.visited)
             return;
         node.visited = true;
@@ -112,13 +215,9 @@ export class CoverageTransform extends Visitor {
                 return;
             node.body.visited = true;
             const path = node.range.source.normalizedPath;
-            const funcLc = getLineCol(node);
-            const point = new CoverPoint();
-            point.line = funcLc?.line;
-            point.column = funcLc?.column;
-            point.file = path;
-            point.type = CoverType.Function;
-            point.hash = hash(point);
+            const methodName = getNodeName(node.name);
+            const scopeKind = methodName == "constructor" ? "Constructor" : "Method";
+            const point = this.createFunctionPoint(path, node, scopeKind, methodName);
             const replacer = new RangeTransform(node);
             const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
@@ -127,6 +226,13 @@ export class CoverageTransform extends Visitor {
             const bodyBlock = node.body;
             bodyBlock.statements.unshift(coverStmt);
             this.globalStatements.push(registerStmt);
+            this.withScope(point, () => {
+                this.visit(node.name, node);
+                this.visit(node.typeParameters, node);
+                this.visit(node.signature, node);
+                this.visit(node.decorators, node);
+                this.visit(bodyBlock.statements, bodyBlock);
+            });
         }
     }
     visitParameter(node) {
@@ -146,7 +252,8 @@ export class CoverageTransform extends Visitor {
             point.line = paramLc?.line;
             point.column = paramLc?.column;
             point.file = path;
-            point.type = CoverType.Expression;
+            point.type = "DefaultValue";
+            this.assignParentMetadata(point);
             point.hash = hash(point);
             const replacer = new RangeTransform(node);
             const registerStmt = createRegisterStatement(point);
@@ -158,7 +265,6 @@ export class CoverageTransform extends Visitor {
         }
     }
     visitFunctionDeclaration(node, isDefault) {
-        super.visitFunctionDeclaration(node, isDefault);
         if (node.visited)
             return;
         node.visited = true;
@@ -167,13 +273,7 @@ export class CoverageTransform extends Visitor {
                 return;
             node.body.visited = true;
             const path = node.range.source.normalizedPath;
-            const funcLc = getLineCol(node);
-            const point = new CoverPoint();
-            point.line = funcLc?.line;
-            point.column = funcLc?.column;
-            point.file = path;
-            point.type = CoverType.Function;
-            point.hash = hash(point);
+            const point = this.createFunctionPoint(path, node, "Function", node.name?.text ?? null);
             const replacer = new RangeTransform(node);
             const registerStmt = createRegisterStatement(point);
             replacer.visit(registerStmt);
@@ -202,6 +302,18 @@ export class CoverageTransform extends Visitor {
                     const bodyBlock = node.body;
                     bodyBlock.statements.unshift(coverStmt);
                 }
+                this.withScope(point, () => {
+                    this.visit(node.name, node);
+                    this.visit(node.decorators, node);
+                    this.visit(node.typeParameters, node);
+                    this.visit(node.signature, node);
+                    if (node.body instanceof BlockStatement) {
+                        this.visit(node.body.statements, node.body);
+                    }
+                    else {
+                        this.visit(node.body, node);
+                    }
+                });
             }
         }
     }
@@ -217,42 +329,14 @@ export class CoverageTransform extends Visitor {
         if (ifTrue &&
             ifTrue.kind !== 31 &&
             !isBuiltinStatement(ifTrue)) {
-            const trueLc = getLineCol(ifTrue);
-            const point = new CoverPoint();
-            point.line = trueLc?.line;
-            point.column = trueLc?.column;
-            point.file = path;
-            point.type = CoverType.Expression;
-            point.hash = hash(point);
-            const replacer = new RangeTransform(ifTrue);
-            const registerStmt = createRegisterStatement(point);
-            replacer.visit(registerStmt);
-            const coverStmt = Node.createBlockStatement([createCoverStatement(point.hash, ifTrue)], ifTrue.range);
-            replacer.visit(coverStmt);
-            coverStmt.statements.push(ifTrue);
-            node.ifTrue = coverStmt;
-            this.globalStatements.push(registerStmt);
+            node.ifTrue = this.instrumentStatementBody(path, ifTrue, "IfBranch");
             visitIfTrue = true;
             visitIfFalse = !!ifFalse;
         }
         if (ifFalse &&
             ifFalse.kind !== 31 &&
             !isBuiltinStatement(ifFalse)) {
-            const falseLc = getLineCol(ifFalse);
-            const point = new CoverPoint();
-            point.line = falseLc?.line;
-            point.column = falseLc?.column;
-            point.file = path;
-            point.type = CoverType.Expression;
-            point.hash = hash(point);
-            const replacer = new RangeTransform(ifFalse);
-            const registerStmt = createRegisterStatement(point);
-            replacer.visit(registerStmt);
-            const coverStmt = Node.createBlockStatement([createCoverStatement(point.hash, ifFalse)], ifFalse.range);
-            replacer.visit(coverStmt);
-            coverStmt.statements.push(ifFalse);
-            node.ifFalse = coverStmt;
-            this.globalStatements.push(registerStmt);
+            node.ifFalse = this.instrumentStatementBody(path, ifFalse, "IfBranch");
             visitIfTrue = true;
             visitIfFalse = true;
         }
@@ -289,7 +373,8 @@ export class CoverageTransform extends Visitor {
                 point.line = trueLc?.line;
                 point.column = trueLc?.column;
                 point.file = path;
-                point.type = CoverType.Expression;
+                point.type = "Ternary";
+                this.assignParentMetadata(point);
                 point.hash = hash(point);
                 const replacer = new RangeTransform(trueExpression);
                 const registerStmt = createRegisterStatement(point);
@@ -307,7 +392,8 @@ export class CoverageTransform extends Visitor {
                 point.line = falseLc?.line;
                 point.column = falseLc?.column;
                 point.file = path;
-                point.type = CoverType.Expression;
+                point.type = "Ternary";
+                this.assignParentMetadata(point);
                 point.hash = hash(point);
                 const replacer = new RangeTransform(falseExpression);
                 const registerStmt = createRegisterStatement(point);
@@ -319,6 +405,72 @@ export class CoverageTransform extends Visitor {
             }
         }
     }
+    visitForStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        const path = node.range.source.normalizedPath;
+        node.body = this.instrumentStatementBody(path, node.body, "Loop");
+        super.visitForStatement(node);
+    }
+    visitForOfStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        const path = node.range.source.normalizedPath;
+        node.body = this.instrumentStatementBody(path, node.body, "Loop");
+        super.visitForOfStatement(node);
+    }
+    visitWhileStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        const path = node.range.source.normalizedPath;
+        node.body = this.instrumentStatementBody(path, node.body, "Loop");
+        super.visitWhileStatement(node);
+    }
+    visitDoStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        const path = node.range.source.normalizedPath;
+        node.body = this.instrumentStatementBody(path, node.body, "Loop");
+        super.visitDoStatement(node);
+    }
+    visitReturnStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        super.visitReturnStatement(node);
+        if (!node.value || isBuiltinCallExpression(node.value))
+            return;
+        const path = node.range.source.normalizedPath;
+        const point = this.createPoint(path, node.value, "Return");
+        const replacer = new RangeTransform(node);
+        const registerStmt = createRegisterStatement(point);
+        replacer.visit(registerStmt);
+        const coverExpression = createCoverExpression(point.hash, node.value, node);
+        replacer.visit(coverExpression);
+        node.value = coverExpression;
+        this.globalStatements.push(registerStmt);
+    }
+    visitThrowStatement(node) {
+        if (node.visited)
+            return;
+        node.visited = true;
+        super.visitThrowStatement(node);
+        if (!node.value || isBuiltinCallExpression(node.value))
+            return;
+        const path = node.range.source.normalizedPath;
+        const point = this.createPoint(path, node.value, "Throw");
+        const replacer = new RangeTransform(node);
+        const registerStmt = createRegisterStatement(point);
+        replacer.visit(registerStmt);
+        const coverExpression = createCoverExpression(point.hash, node.value, node);
+        replacer.visit(coverExpression);
+        node.value = coverExpression;
+        this.globalStatements.push(registerStmt);
+    }
     visitSwitchCase(node) {
         if (node.visited)
             return;
@@ -329,7 +481,8 @@ export class CoverageTransform extends Visitor {
         point.line = caseLc?.line;
         point.column = caseLc?.column;
         point.file = path;
-        point.type = CoverType.Block;
+        point.type = "SwitchCase";
+        this.assignParentMetadata(point);
         point.hash = hash(point);
         const replacer = new RangeTransform(node);
         const registerStmt = createRegisterStatement(point);
@@ -354,7 +507,8 @@ export class CoverageTransform extends Visitor {
         point.line = blockLc?.line;
         point.column = blockLc?.column;
         point.file = path;
-        point.type = CoverType.Block;
+        point.type = "Block";
+        this.assignParentMetadata(point);
         point.hash = hash(point);
         const replacer = new RangeTransform(node);
         const registerStmt = createRegisterStatement(point);
@@ -413,6 +567,11 @@ function getExpressionName(node) {
             return null;
     }
 }
+function getNodeName(node) {
+    if (!node)
+        return null;
+    return getExpressionName(node);
+}
 function djb2Hash(str) {
     const points = Array.from(str);
     let h = 5381;
@@ -444,7 +603,7 @@ function getLineCol(node) {
     };
 }
 function createRegisterStatement(point) {
-    return SimpleParser.parseTopLevelStatement(`__REGISTER_RAW(${asStringLiteral(point.file)}, ${asStringLiteral(point.hash)}, ${point.line}, ${point.column}, ${asStringLiteral(coverTypeToString(point.type))})`);
+    return SimpleParser.parseTopLevelStatement(`__REGISTER_RAW(${asStringLiteral(point.file)}, ${asStringLiteral(point.hash)}, ${point.line}, ${point.column}, ${asStringLiteral(point.type)}, ${asStringLiteral(point.parentHash)}, ${asStringLiteral(point.scopeKind)}, ${asStringLiteral(point.scopeName)}, ${point.depth})`);
 }
 function createCoverStatement(hashValue, ref) {
     return Node.createExpressionStatement(createCoverCallExpression(hashValue, ref));
@@ -455,16 +614,6 @@ function createCoverExpression(hashValue, replacement, ref) {
 function createCoverCallExpression(hashValue, ref) {
     return Node.createCallExpression(Node.createIdentifierExpression("__COVER", ref.range), null, [Node.createStringLiteralExpression(hashValue, ref.range)], ref.range);
 }
-function coverTypeToString(type) {
-    switch (type) {
-        case CoverType.Function:
-            return "Function";
-        case CoverType.Expression:
-            return "Expression";
-        default:
-            return "Block";
-    }
-}
 function asStringLiteral(value) {
     return JSON.stringify(value);
 }