just use v8-to-istanbul

.vscode/extensions/vscode-selfhost-test-provider/src/coverageProvider.ts

@@ -3,121 +3,104 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { TraceMap } from '@jridgewell/trace-mapping';
 import { IstanbulCoverageContext } from 'istanbul-to-vscode';
-import { SourceMapStore } from './testOutputScanner';
+import { fileURLToPath } from 'url';
 import * as vscode from 'vscode';
-import { IScriptCoverage, OffsetToPosition, RangeCoverageTracker } from './v8CoverageWrangling';
-import * as v8ToIstanbul from 'v8-to-istanbul';
+import { SourceMapStore } from './sourceMapStore';
+import v8ToIstanbul = require('v8-to-istanbul');
 
 export const istanbulCoverageContext = new IstanbulCoverageContext();
 
+export interface ICoverageRange {
+	start: number;
+	end: number;
+	covered: boolean;
+}
+
+export interface IV8FunctionCoverage {
+	functionName: string;
+	isBlockCoverage: boolean;
+	ranges: IV8CoverageRange[];
+}
+
+export interface IV8CoverageRange {
+	startOffset: number;
+	endOffset: number;
+	count: number;
+}
+
+/** V8 Script coverage data */
+export interface IScriptCoverage {
+	scriptId: string;
+	url: string;
+	// Script source added by the runner the first time the script is emitted.
+	source?: string;
+	functions: IV8FunctionCoverage[];
+}
+
 /**
  * Tracks coverage in per-script coverage mode. There are two modes of coverage
- * in this extension: generic istanbul reports, and reports from the runtime
+ * in this extension: generic istanbul reports, and V8 reports from the runtime
  * sent before and after each test case executes. This handles the latter.
  */
 export class PerTestCoverageTracker {
 	private readonly scripts = new Map</* script ID */ string, Script>();
 
-	constructor(
-		private readonly initialCoverage: IScriptCoverage,
-		private readonly maps: SourceMapStore,
-	) {}
+	constructor(private readonly maps: SourceMapStore) { }
 
-	public add(coverage: IScriptCoverage, test?: vscode.TestItem) {
-		const script = this.scripts.get(coverage.scriptId);
-		if (script) {
-			return script.add(coverage, test);
-		}
-		if (!coverage.source) {
-			throw new Error('expected to have source the first time a script is seen');
+	/** Adds new coverage data to the run, optionally for a test item. */
+	public add(run: vscode.TestRun, coverage: IScriptCoverage, test?: vscode.TestItem) {
+		let script = this.scripts.get(coverage.scriptId);
+		if (!script) {
+			if (!coverage.source) {
+				throw new Error('expected to have source the first time a script is seen');
+			}
+
+			script = new Script(coverage.url, coverage.source, this.maps);
+			this.scripts.set(coverage.scriptId, script);
 		}
 
-		const src = new Script(coverage.url, coverage.source, this.maps);
+		return script.add(run, coverage, test);
 	}
 }
 
 class Script {
-	private converter: OffsetToPosition;
-
-	/** Tracking the overall coverage for the file */
-	private overall = new ScriptProjection();
-	/** Range tracking per-test item */
-	private readonly perItem = new Map<vscode.TestItem, ScriptProjection>();
+	private sourceMap?: Promise<TraceMap | undefined>;
+	private originalContent?: Promise<string | undefined>;
 
 	constructor(
 		public readonly url: string,
-		source: string,
+		private readonly source: string,
 		private readonly maps: SourceMapStore,
 	) {
-		this.converter = new OffsetToPosition(source);
 	}
 
-	public add(coverage: IScriptCoverage, test?: vscode.TestItem) {
-		this.overall.add(coverage);
-		if (test) {
-			const p = new ScriptProjection();
-			p.add(coverage);
-			this.perItem.set(test, p);
+	public async add(run: vscode.TestRun, coverage: IScriptCoverage, test?: vscode.TestItem) {
+		if (!coverage.url.startsWith('file://')) {
+			return;
 		}
-	}
 
-	public report(run: vscode.TestRun) {
-
-	}
-}
-
-class ScriptProjection {
-	/** Range tracking for non-block coverage in the file */
-	private file = new RangeCoverageTracker();
-	/** Range tracking for block coverage in the file */
-	private readonly blocks = new Map<string, RangeCoverageTracker>();
-
-	public add(coverage: IScriptCoverage) {
-
-		for (const fn of coverage.functions) {
-			if (fn.isBlockCoverage) {
-				const key = `${fn.ranges[0].startOffset}/${fn.ranges[0].endOffset}`;
-				const block = this.blocks.get(key);
-				if (block) {
-					for (let i = 1; i < fn.ranges.length; i++) {
-						block.setCovered(fn.ranges[i].startOffset, fn.ranges[i].endOffset, fn.ranges[i].count > 0);
-					}
-				} else {
-					this.blocks.set(key, RangeCoverageTracker.initializeBlock(fn.ranges));
-				}
-			} else {
-				for (const range of fn.ranges) {
-					this.file.setCovered(range.startOffset, range.endOffset, range.count > 0);
-				}
-			}
-		}
-	}
-
-	public report(run: vscode.TestRun, convert: OffsetToPosition, item?: vscode.TestItem) {
-		const ranges = [...this.file];
-		for (const block of this.blocks.values()) {
-			for (const range of block) {
-				ranges.push(range);
-			}
-		}
-
-		let ri = 0;
-		ranges.sort((a, b) => a.end - b.end);
-
-		let offset = 0;
-		for (let i = 0; i < convert.lines.length; i++) {
-			const lineEnd = offset + convert.lines[i] + 1;
-
-			const coverage = new RangeCoverageTracker();
-			for (let i = ri; i < ranges.length && ranges[i].start < lineEnd; i++) {
-				coverage.setCovered(ranges[i].start - offset, ranges[i].end - offset, ranges[i].covered);
-			}
-
-			while (ri < ranges.length && ranges[ri].end < lineEnd) {
-				ri++;
-			}
-		}
+		const sourceMap = await (this.sourceMap ??= this.maps.loadSourceMap(coverage.url));
+		const originalSource = await (this.originalContent ??= this.maps.getSourceFileContents(coverage.url));
+		const istanbuled = v8ToIstanbul(fileURLToPath(coverage.url), undefined, sourceMap && originalSource
+			? { source: this.source, originalSource, sourceMap: { sourcemap: sourceMap } }
+			: { source: this.source }
+		);
 
+		await istanbuled.load();
+
+		const coverages = await istanbulCoverageContext.fromJson(istanbuled.toIstanbul(), {
+			mapFileUri: uri => this.maps.getSourceFile(uri.toString()),
+			mapLocation: (uri, position) =>
+				this.maps.getSourceLocation(uri.toString(), position.line, position.character),
+		});
+
+		for (const coverage of coverages) {
+			if (test) {
+				(coverage as vscode.FileCoverage2).testItem = test;
+			}
+			run.addCoverage(coverage);
+		}
 	}
 }

.vscode/extensions/vscode-selfhost-test-provider/src/sourceMapStore.ts

@@ -0,0 +1,102 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import {
+	GREATEST_LOWER_BOUND,
+	LEAST_UPPER_BOUND,
+	originalPositionFor,
+	TraceMap
+} from '@jridgewell/trace-mapping';
+import * as vscode from 'vscode';
+import { getContentFromFilesystem } from './testTree';
+
+const inlineSourcemapRe = /^\/\/# sourceMappingURL=data:application\/json;base64,(.+)/m;
+const sourceMapBiases = [GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND] as const;
+
+export class SourceMapStore {
+	private readonly cache = new Map</* file uri */ string, Promise<TraceMap | undefined>>();
+
+	async getSourceLocation(fileUri: string, line: number, col = 1) {
+		const sourceMap = await this.loadSourceMap(fileUri);
+		if (!sourceMap) {
+			return undefined;
+		}
+
+		for (const bias of sourceMapBiases) {
+			const position = originalPositionFor(sourceMap, { column: col, line: line + 1, bias });
+			if (position.line !== null && position.column !== null && position.source !== null) {
+				return new vscode.Location(
+					this.completeSourceMapUrl(sourceMap, position.source),
+					new vscode.Position(position.line - 1, position.column)
+				);
+			}
+		}
+
+		return undefined;
+	}
+
+	async getSourceFile(compiledUri: string) {
+		const sourceMap = await this.loadSourceMap(compiledUri);
+		if (!sourceMap) {
+			return undefined;
+		}
+
+		if (sourceMap.sources[0]) {
+			return this.completeSourceMapUrl(sourceMap, sourceMap.sources[0]);
+		}
+
+		for (const bias of sourceMapBiases) {
+			const position = originalPositionFor(sourceMap, { column: 0, line: 1, bias });
+			if (position.source !== null) {
+				return this.completeSourceMapUrl(sourceMap, position.source);
+			}
+		}
+
+		return undefined;
+	}
+
+	async getSourceFileContents(compiledUri: string) {
+		const sourceUri = await this.getSourceFile(compiledUri);
+		return sourceUri ? getContentFromFilesystem(sourceUri) : undefined;
+	}
+
+	private completeSourceMapUrl(sm: TraceMap, source: string) {
+		if (sm.sourceRoot) {
+			try {
+				return vscode.Uri.parse(new URL(source, sm.sourceRoot).toString());
+			} catch {
+				// ignored
+			}
+		}
+
+		return vscode.Uri.parse(source);
+	}
+
+	public loadSourceMap(fileUri: string) {
+		const existing = this.cache.get(fileUri);
+		if (existing) {
+			return existing;
+		}
+
+		const promise = (async () => {
+			try {
+				const contents = await getContentFromFilesystem(vscode.Uri.parse(fileUri));
+				const sourcemapMatch = inlineSourcemapRe.exec(contents);
+				if (!sourcemapMatch) {
+					return;
+				}
+
+				const decoded = Buffer.from(sourcemapMatch[1], 'base64').toString();
+				return new TraceMap(decoded, fileUri);
+			} catch (e) {
+				console.warn(`Error parsing sourcemap for ${fileUri}: ${(e as Error).stack}`);
+				return;
+			}
+		})();
+
+		this.cache.set(fileUri, promise);
+		return promise;
+	}
+}

.vscode/extensions/vscode-selfhost-test-provider/src/testOutputScanner.ts

@@ -3,19 +3,13 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import {
-	GREATEST_LOWER_BOUND,
-	LEAST_UPPER_BOUND,
-	originalPositionFor,
-	TraceMap,
-} from '@jridgewell/trace-mapping';
 import * as styles from 'ansi-styles';
 import { ChildProcessWithoutNullStreams } from 'child_process';
 import * as vscode from 'vscode';
-import { IScriptCoverage, istanbulCoverageContext } from './coverageProvider';
+import { IScriptCoverage, PerTestCoverageTracker, istanbulCoverageContext } from './coverageProvider';
 import { attachTestMessageMetadata } from './metadata';
 import { snapshotComment } from './snapshot';
-import { getContentFromFilesystem } from './testTree';
+import { SourceMapStore } from './sourceMapStore';
 import { StreamSplitter } from './streamSplitter';
 
 export const enum MochaEvent {
@@ -174,6 +168,7 @@ export async function scanTestOutput(
 
 	let lastTest: vscode.TestItem | undefined;
 	let ranAnyTest = false;
+	let perTestCoverage: PerTestCoverageTracker | undefined;
 
 	try {
 		if (cancellation.isCancellationRequested) {
@@ -319,6 +314,19 @@ export async function scanTestOutput(
 					case MochaEvent.End:
 						// no-op, we wait until the process exits to ensure coverage is written out
 						break;
+					case MochaEvent.CoverageInit:
+						perTestCoverage ??= new PerTestCoverageTracker(store);
+						enqueueExitBlocker(perTestCoverage.add(task, evt[1]));
+						break;
+					case MochaEvent.CoverageIncrement: {
+						const { fullTitle, coverage } = evt[1];
+						const tcase = tests.get(fullTitle);
+						if (tcase) {
+							perTestCoverage ??= new PerTestCoverageTracker(store);
+							enqueueExitBlocker(perTestCoverage.add(task, coverage, tcase));
+						}
+						break;
+					}
 				}
 			});
 		});
@@ -400,90 +408,6 @@ const tryMakeMarkdown = (message: string) => {
 	return new vscode.MarkdownString(lines.join('\n'));
 };
 
-const inlineSourcemapRe = /^\/\/# sourceMappingURL=data:application\/json;base64,(.+)/m;
-const sourceMapBiases = [GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND] as const;
-
-export class SourceMapStore {
-	private readonly cache = new Map</* file uri */ string, Promise<TraceMap | undefined>>();
-
-	async getSourceLocation(fileUri: string, line: number, col = 1) {
-		const sourceMap = await this.loadSourceMap(fileUri);
-		if (!sourceMap) {
-			return undefined;
-		}
-
-		for (const bias of sourceMapBiases) {
-			const position = originalPositionFor(sourceMap, { column: col, line: line + 1, bias });
-			if (position.line !== null && position.column !== null && position.source !== null) {
-				return new vscode.Location(
-					this.completeSourceMapUrl(sourceMap, position.source),
-					new vscode.Position(position.line - 1, position.column)
-				);
-			}
-		}
-
-		return undefined;
-	}
-
-	async getSourceFile(compiledUri: string) {
-		const sourceMap = await this.loadSourceMap(compiledUri);
-		if (!sourceMap) {
-			return undefined;
-		}
-
-		if (sourceMap.sources[0]) {
-			return this.completeSourceMapUrl(sourceMap, sourceMap.sources[0]);
-		}
-
-		for (const bias of sourceMapBiases) {
-			const position = originalPositionFor(sourceMap, { column: 0, line: 1, bias });
-			if (position.source !== null) {
-				return this.completeSourceMapUrl(sourceMap, position.source);
-			}
-		}
-
-		return undefined;
-	}
-
-	private completeSourceMapUrl(sm: TraceMap, source: string) {
-		if (sm.sourceRoot) {
-			try {
-				return vscode.Uri.parse(new URL(source, sm.sourceRoot).toString());
-			} catch {
-				// ignored
-			}
-		}
-
-		return vscode.Uri.parse(source);
-	}
-
-	private loadSourceMap(fileUri: string) {
-		const existing = this.cache.get(fileUri);
-		if (existing) {
-			return existing;
-		}
-
-		const promise = (async () => {
-			try {
-				const contents = await getContentFromFilesystem(vscode.Uri.parse(fileUri));
-				const sourcemapMatch = inlineSourcemapRe.exec(contents);
-				if (!sourcemapMatch) {
-					return;
-				}
-
-				const decoded = Buffer.from(sourcemapMatch[1], 'base64').toString();
-				return new TraceMap(decoded, fileUri);
-			} catch (e) {
-				console.warn(`Error parsing sourcemap for ${fileUri}: ${(e as Error).stack}`);
-				return;
-			}
-		})();
-
-		this.cache.set(fileUri, promise);
-		return promise;
-	}
-}
-
 const locationRe = /(file:\/{3}.+):([0-9]+):([0-9]+)/g;
 
 async function replaceAllLocations(store: SourceMapStore, str: string) {

.vscode/extensions/vscode-selfhost-test-provider/src/v8CoverageWrangling.test.ts

@@ -1,106 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import * as assert from 'assert';
-import { RangeCoverageTracker } from './v8CoverageWrangling';
-
-suite('v8CoverageWrangling', () => {
-	suite('RangeCoverageTracker', () => {
-		test('covers new range', () => {
-			const rt = new RangeCoverageTracker();
-			rt.cover(5, 10);
-			assert.deepStrictEqual([...rt], [{ start: 5, end: 10, covered: true }]);
-		});
-
-		test('non overlapping ranges', () => {
-			const rt = new RangeCoverageTracker();
-			rt.cover(5, 10);
-			rt.cover(15, 20);
-			assert.deepStrictEqual([...rt], [
-				{ start: 5, end: 10, covered: true },
-				{ start: 15, end: 20, covered: true },
-			]);
-		});
-
-		test('covers exact', () => {
-			const rt = new RangeCoverageTracker();
-			rt.uncovered(5, 10);
-			rt.cover(5, 10);
-			assert.deepStrictEqual([...rt], [
-				{ start: 5, end: 10, covered: true },
-			]);
-		});
-
-		test('overlap at start', () => {
-			const rt = new RangeCoverageTracker();
-			rt.uncovered(5, 10);
-			rt.cover(2, 7);
-			assert.deepStrictEqual([...rt], [
-				{ start: 2, end: 5, covered: true },
-				{ start: 5, end: 7, covered: true },
-				{ start: 7, end: 10, covered: false },
-			]);
-		});
-
-		test('overlap at end', () => {
-			const rt = new RangeCoverageTracker();
-			rt.cover(5, 10);
-			rt.uncovered(2, 7);
-			assert.deepStrictEqual([...rt], [
-				{ start: 2, end: 5, covered: false },
-				{ start: 5, end: 7, covered: true },
-				{ start: 7, end: 10, covered: true },
-			]);
-		});
-
-		test('inner contained', () => {
-			const rt = new RangeCoverageTracker();
-			rt.cover(5, 10);
-			rt.uncovered(2, 12);
-			assert.deepStrictEqual([...rt], [
-				{ start: 2, end: 5, covered: false },
-				{ start: 5, end: 10, covered: true },
-				{ start: 10, end: 12, covered: false },
-			]);
-		});
-
-		test('outer contained', () => {
-			const rt = new RangeCoverageTracker();
-			rt.uncovered(5, 10);
-			rt.cover(7, 9);
-			assert.deepStrictEqual([...rt], [
-				{ start: 5, end: 7, covered: false },
-				{ start: 7, end: 9, covered: true },
-				{ start: 9, end: 10, covered: false },
-			]);
-		});
-
-		test('boundary touching', () => {
-			const rt = new RangeCoverageTracker();
-			rt.uncovered(5, 10);
-			rt.cover(10, 15);
-			rt.uncovered(15, 20);
-			assert.deepStrictEqual([...rt], [
-				{ start: 5, end: 10, covered: false },
-				{ start: 10, end: 15, covered: true },
-				{ start: 15, end: 20, covered: false },
-			]);
-		});
-
-		test('initializeBlock', () => {
-			const rt = RangeCoverageTracker.initializeBlock([
-				{ count: 1, startOffset: 5, endOffset: 30 },
-				{ count: 1, startOffset: 8, endOffset: 10 },
-				{ count: 0, startOffset: 15, endOffset: 20 },
-			]);
-
-			assert.deepStrictEqual([...rt], [
-				{ start: 5, end: 15, covered: true },
-				{ start: 15, end: 20, covered: false },
-				{ start: 20, end: 30, covered: true },
-			]);
-		});
-	});
-});

.vscode/extensions/vscode-selfhost-test-provider/src/v8CoverageWrangling.ts

@@ -1,156 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-export interface ICoverageRange {
-	start: number;
-	end: number;
-	covered: boolean;
-}
-
-export interface IV8FunctionCoverage {
-	functionName: string;
-	isBlockCoverage: boolean;
-	ranges: IV8CoverageRange[];
-}
-
-export interface IV8CoverageRange {
-	startOffset: number;
-	endOffset: number;
-	count: number;
-}
-
-/** V8 Script coverage data */
-export interface IScriptCoverage {
-	scriptId: string;
-	url: string;
-	// Script source added by the runner the first time the script is emitted.
-	source?: string;
-	functions: IV8FunctionCoverage[];
-}
-
-
-export class RangeCoverageTracker implements Iterable<ICoverageRange> {
-	/**
-	 * A noncontiguous, non-overlapping, ordered set of ranges and whether
-	 * that range has been covered.
-	 */
-	private ranges: readonly ICoverageRange[] = [];
-
-	/**
-	 * Adds a coverage tracker initialized for a function with {@link isBlockCoverage} set to true.
-	 */
-	public static initializeBlock(ranges: IV8CoverageRange[]) {
-		let start = ranges[0].startOffset;
-		const rt = new RangeCoverageTracker();
-		if (!ranges[0].count) {
-			rt.uncovered(start, ranges[0].endOffset);
-			return rt;
-		}
-
-		for (let i = 1; i < ranges.length; i++) {
-			const range = ranges[i];
-			if (range.count) {
-				continue;
-			}
-
-			rt.cover(start, range.startOffset);
-			rt.uncovered(range.startOffset, range.endOffset);
-			start = range.endOffset;
-		}
-
-		rt.cover(start, ranges[0].endOffset);
-		return rt;
-	}
-
-	/** Marks a range covered */
-	public cover(start: number, end: number) {
-		this.setCovered(start, end, true);
-	}
-
-	/** Marks a range as uncovered */
-	public uncovered(start: number, end: number) {
-		this.setCovered(start, end, false);
-	}
-
-	/** Iterates over coverage ranges */
-	[Symbol.iterator]() {
-		return this.ranges[Symbol.iterator]();
-	}
-
-	public setCovered(start: number, end: number, covered: boolean) {
-		const newRanges: ICoverageRange[] = [];
-		let i = 0;
-		for (; i < this.ranges.length && this.ranges[i].end <= start; i++) {
-			newRanges.push(this.ranges[i]);
-		}
-
-		newRanges.push({ start, end, covered });
-		for (; i < this.ranges.length; i++) {
-			const range = this.ranges[i];
-			const last = newRanges[newRanges.length - 1];
-
-			if (range.start < last.start && range.end > last.end) {
-				// range contains last:
-				newRanges.pop();
-				newRanges.push({ start: range.start, end: last.start, covered: range.covered });
-				newRanges.push({ start: last.start, end: last.end, covered: range.covered || last.covered });
-				newRanges.push({ start: last.end, end: range.end, covered: range.covered });
-			} else if (range.start > last.start && range.end <= last.end) {
-				// last contains range:
-				newRanges.pop();
-				newRanges.push({ start: last.start, end: range.start, covered: last.covered });
-				newRanges.push({ start: range.start, end: range.end, covered: range.covered || last.covered });
-				newRanges.push({ start: range.end, end: last.end, covered: last.covered });
-			} else if (range.start < last.start && range.end <= last.end) {
-				// range overlaps start of last:
-				newRanges.pop();
-				newRanges.push({ start: range.start, end: last.start, covered: range.covered });
-				newRanges.push({ start: last.start, end: range.end, covered: range.covered || last.covered });
-				newRanges.push({ start: range.end, end: last.end, covered: last.covered });
-			} else if (range.start > last.start && range.end > last.end) {
-				// range overlaps end of last:
-				newRanges.pop();
-				newRanges.push({ start: last.start, end: range.start, covered: last.covered });
-				newRanges.push({ start: range.start, end: last.end, covered: range.covered || last.covered });
-				newRanges.push({ start: last.end, end: range.end, covered: range.covered });
-			} else {
-				// ranges are equal:
-				last.covered ||= range.covered;
-			}
-		}
-
-		this.ranges = newRanges;
-	}
-}
-
-export class OffsetToPosition {
-	/** Line numbers to byte offsets. */
-  public readonly lines: number[] = [];
-
-  constructor(public readonly source: string) {
-    this.lines.push(0);
-    for (let i = source.indexOf('\n'); i !== -1; i = source.indexOf('\n', i + 1)) {
-      this.lines.push(i + 1);
-    }
-  }
-
-  /**
-   * Converts from a file offset to a base 0 line/column .
-   */
-  public convert(offset: number): { line: number; column: number } {
-		let low = 0;
-		let high = this.lines.length;
-		while (low < high) {
-			const mid = Math.floor((low + high) / 2);
-			if (this.lines[mid] > offset) {
-				high = mid;
-			} else {
-				low = mid + 1;
-			}
-		}
-
-		return { line: low - 1, column: offset - this.lines[low - 1] };
-  }
-}