Merge pull request #627 from codestoryai/fetch-upstream-200524

Fetch upstream 200524

Author: ghostwriternr

.eslintplugin/code-no-dangerous-type-assertions.ts

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+
+export = new class NoDangerousTypeAssertions implements eslint.Rule.RuleModule {
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+		// Disable in tests for now
+		if (context.getFilename().includes('.test')) {
+			return {};
+		}
+
+		return {
+			// Disallow type assertions on object literals: <T>{ ... } or {} as T
+			['TSTypeAssertion > ObjectExpression, TSAsExpression > ObjectExpression']: (node: any) => {
+				const objectNode = node as TSESTree.Node;
+
+				const parent = objectNode.parent as TSESTree.TSTypeAssertion | TSESTree.TSAsExpression;
+				if (
+					// Allow `as const` assertions
+					(parent.typeAnnotation.type === 'TSTypeReference' && parent.typeAnnotation.typeName.type === 'Identifier' && parent.typeAnnotation.typeName.name === 'const')
+
+					// For also now still allow `any` casts
+					|| (parent.typeAnnotation.type === 'TSAnyKeyword')
+				) {
+					return;
+				}
+
+				context.report({
+					node,
+					message: "Don't use type assertions for creating objects as this can hide type errors."
+				});
+			},
+		};
+	}
+};

.eslintrc.json

@@ -73,6 +73,7 @@
 		"local/code-parameter-properties-must-have-explicit-accessibility": "warn",
 		"local/code-no-nls-in-standalone-editor": "warn",
 		"local/code-no-potentially-unsafe-disposables": "warn",
+		"local/code-no-dangerous-type-assertions": "off",
 		"local/code-no-standalone-editor": "warn",
 		"local/code-no-unexternalized-strings": "warn",
 		"local/code-must-use-super-dispose": "warn",
@@ -671,7 +672,6 @@
 							"vscode-regexpp",
 							"vscode-textmate",
 							"worker_threads",
-							"@xterm/addon-canvas",
 							"@xterm/addon-image",
 							"@xterm/addon-search",
 							"@xterm/addon-serialize",

.nvmrc

@@ -1 +1 @@
-18.19.0
+20.12.1

.vscode/extensions/vscode-selfhost-test-provider/.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+	"configurations": [
+		{
+			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--enable-proposed-api=ms-vscode.vscode-selfhost-test-provider"],
+			"name": "Launch Extension",
+			"outFiles": ["${workspaceFolder}/out/**/*.js"],
+			"request": "launch",
+			"type": "extensionHost"
+		}
+	]
+}

.vscode/extensions/vscode-selfhost-test-provider/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+	"editor.formatOnSave": true,
+	"editor.defaultFormatter": "vscode.typescript-language-features",
+	"editor.codeActionsOnSave": {
+		"source.organizeImports": "always"
+	}
+}

.vscode/extensions/vscode-selfhost-test-provider/package.json

@@ -3,7 +3,8 @@
   "displayName": "VS Code Selfhost Test Provider",
   "description": "Test provider for the VS Code project",
   "enabledApiProposals": [
-    "testObserver"
+    "testObserver",
+    "attributableCoverage"
   ],
   "engines": {
     "vscode": "^1.88.0"
@@ -13,6 +14,13 @@
       {
         "command": "selfhost-test-provider.updateSnapshot",
         "title": "Update Snapshot",
+        "category": "Testing",
+        "icon": "$(merge)"
+      },
+      {
+        "command": "selfhost-test-provider.openFailureLog",
+        "title": "Open Selfhost Failure Logs",
+        "category": "Testing",
         "icon": "$(merge)"
       }
     ],
@@ -65,10 +73,12 @@
   "license": "MIT",
   "scripts": {
     "compile": "gulp compile-extension:vscode-selfhost-test-provider",
-    "watch": "gulp watch-extension:vscode-selfhost-test-provider"
+    "watch": "gulp watch-extension:vscode-selfhost-test-provider",
+    "test": "npx mocha --ui tdd 'out/*.test.js'"
   },
   "devDependencies": {
-    "@types/node": "18.x"
+    "@types/mocha": "^10.0.6",
+    "@types/node": "20.x"
   },
   "dependencies": {
     "@jridgewell/trace-mapping": "^0.3.25",

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

@@ -4,5 +4,154 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IstanbulCoverageContext } from 'istanbul-to-vscode';
+import * as vscode from 'vscode';
+import { SourceLocationMapper, SourceMapStore } from './testOutputScanner';
+import { IScriptCoverage, OffsetToPosition, RangeCoverageTracker } from './v8CoverageWrangling';
 
-export const coverageContext = new IstanbulCoverageContext();
+export const istanbulCoverageContext = new IstanbulCoverageContext();
+
+/**
+ * Tracks coverage in per-script coverage mode. There are two modes of coverage
+ * in this extension: generic istanbul reports, and 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 maps: SourceMapStore) {}
+
+	public add(coverage: IScriptCoverage, test?: vscode.TestItem) {
+		const script = this.scripts.get(coverage.scriptId);
+		if (script) {
+			return script.add(coverage, test);
+		}
+		// ignore internals and node_modules
+		if (!coverage.url.startsWith('file://') || coverage.url.includes('node_modules')) {
+			return;
+		}
+		if (!coverage.source) {
+			throw new Error('expected to have source the first time a script is seen');
+		}
+
+		const src = new Script(vscode.Uri.parse(coverage.url), coverage.source, this.maps);
+		this.scripts.set(coverage.scriptId, src);
+		src.add(coverage, test);
+	}
+
+	public async report(run: vscode.TestRun) {
+		await Promise.all(Array.from(this.scripts.values()).map(s => s.report(run)));
+	}
+}
+
+class Script {
+	private converter: OffsetToPosition;
+
+	/** Tracking the overall coverage for the file */
+	private overall = new ScriptCoverageTracker();
+	/** Range tracking per-test item */
+	private readonly perItem = new Map<vscode.TestItem, ScriptCoverageTracker>();
+
+	constructor(
+		public readonly uri: vscode.Uri,
+		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 ScriptCoverageTracker();
+			p.add(coverage);
+			this.perItem.set(test, p);
+		}
+	}
+
+	public async report(run: vscode.TestRun) {
+		const mapper = await this.maps.getSourceLocationMapper(this.uri.toString());
+		const originalUri = (await this.maps.getSourceFile(this.uri.toString())) || this.uri;
+
+		run.addCoverage(this.overall.report(originalUri, this.converter, mapper));
+		for (const [test, projection] of this.perItem) {
+			run.addCoverage(projection.report(originalUri, this.converter, mapper, test));
+		}
+	}
+}
+
+class ScriptCoverageTracker {
+	private coverage = new RangeCoverageTracker();
+
+	public add(coverage: IScriptCoverage) {
+		for (const range of RangeCoverageTracker.initializeBlocks(coverage.functions)) {
+			this.coverage.setCovered(range.start, range.end, range.covered);
+		}
+	}
+
+	/**
+	 * Generates the script's coverage for the test run.
+	 *
+	 * If a source location mapper is given, it assumes the `uri` is the mapped
+	 * URI, and that any unmapped locations/outside the URI should be ignored.
+	 */
+	public report(
+		uri: vscode.Uri,
+		convert: OffsetToPosition,
+		mapper: SourceLocationMapper | undefined,
+		item?: vscode.TestItem
+	): V8CoverageFile {
+		const file = new V8CoverageFile(uri, item);
+
+		for (const range of this.coverage) {
+			if (range.start === range.end) {
+				continue;
+			}
+
+			const startCov = convert.toLineColumn(range.start);
+			let start = new vscode.Position(startCov.line, startCov.column);
+
+			const endCov = convert.toLineColumn(range.end);
+			let end = new vscode.Position(endCov.line, endCov.column);
+			if (mapper) {
+				const startMap = mapper(start.line, start.character);
+				const endMap = startMap && mapper(end.line, end.character);
+				if (!endMap || uri.toString().toLowerCase() !== endMap.uri.toString().toLowerCase()) {
+					continue;
+				}
+				start = startMap.range.start;
+				end = endMap.range.end;
+			}
+
+			for (let i = start.line; i <= end.line; i++) {
+				file.add(
+					new vscode.StatementCoverage(
+						range.covered,
+						new vscode.Range(
+							new vscode.Position(i, i === start.line ? start.character : 0),
+							new vscode.Position(i, i === end.line ? end.character : Number.MAX_SAFE_INTEGER)
+						)
+					)
+				);
+			}
+		}
+
+		return file;
+	}
+}
+
+export class V8CoverageFile extends vscode.FileCoverage {
+	public details: vscode.StatementCoverage[] = [];
+
+	constructor(uri: vscode.Uri, item?: vscode.TestItem) {
+		super(uri, { covered: 0, total: 0 });
+		(this as vscode.FileCoverage2).testItem = item;
+	}
+
+	public add(detail: vscode.StatementCoverage) {
+		this.details.push(detail);
+		this.statementCoverage.total++;
+		if (detail.executed) {
+			this.statementCoverage.covered++;
+		}
+	}
+}

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

@@ -7,8 +7,9 @@ import { randomBytes } from 'crypto';
 import { tmpdir } from 'os';
 import * as path from 'path';
 import * as vscode from 'vscode';
-import { coverageContext } from './coverageProvider';
+import { V8CoverageFile } from './coverageProvider';
 import { FailingDeepStrictEqualAssertFixer } from './failingDeepStrictEqualAssertFixer';
+import { FailureTracker } from './failureTracker';
 import { registerSnapshotUpdate } from './snapshot';
 import { scanTestOutput } from './testOutputScanner';
 import {
@@ -24,7 +25,7 @@ const TEST_FILE_PATTERN = 'src/vs/**/*.{test,integrationTest}.ts';
 
 const getWorkspaceFolderForTestFile = (uri: vscode.Uri) =>
 	(uri.path.endsWith('.test.ts') || uri.path.endsWith('.integrationTest.ts')) &&
-		uri.path.includes('/src/vs/')
+	uri.path.includes('/src/vs/')
 		? vscode.workspace.getWorkspaceFolder(uri)
 		: undefined;
 
@@ -54,8 +55,14 @@ export async function activate(context: vscode.ExtensionContext) {
 		}
 	};
 
+	guessWorkspaceFolder().then(folder => {
+		if (folder) {
+			context.subscriptions.push(new FailureTracker(context, folder.uri.fsPath));
+		}
+	});
+
 	const createRunHandler = (
-		runnerCtor: { new(folder: vscode.WorkspaceFolder): VSCodeTestRunner },
+		runnerCtor: { new (folder: vscode.WorkspaceFolder): VSCodeTestRunner },
 		kind: vscode.TestRunProfileKind,
 		args: string[] = []
 	) => {
@@ -78,17 +85,23 @@ export async function activate(context: vscode.ExtensionContext) {
 			let coverageDir: string | undefined;
 			let currentArgs = args;
 			if (kind === vscode.TestRunProfileKind.Coverage) {
-				coverageDir = path.join(tmpdir(), `vscode-test-coverage-${randomBytes(8).toString('hex')}`);
-				currentArgs = [
-					...currentArgs,
-					'--coverage',
-					'--coveragePath',
-					coverageDir,
-					'--coverageFormats',
-					'json',
-					'--coverageFormats',
-					'html',
-				];
+				// todo: browser runs currently don't support per-test coverage
+				if (args.includes('--browser')) {
+					coverageDir = path.join(
+						tmpdir(),
+						`vscode-test-coverage-${randomBytes(8).toString('hex')}`
+					);
+					currentArgs = [
+						...currentArgs,
+						'--coverage',
+						'--coveragePath',
+						coverageDir,
+						'--coverageFormats',
+						'json',
+					];
+				} else {
+					currentArgs = [...currentArgs, '--per-test-coverage'];
+				}
 			}
 
 			return await scanTestOutput(
@@ -172,7 +185,13 @@ export async function activate(context: vscode.ExtensionContext) {
 		true
 	);
 
-	coverage.loadDetailedCoverage = coverageContext.loadDetailedCoverage;
+	coverage.loadDetailedCoverage = async (_run, coverage) => {
+		if (coverage instanceof V8CoverageFile) {
+			return coverage.details;
+		}
+
+		return [];
+	};
 
 	for (const [name, arg] of browserArgs) {
 		const cfg = ctrl.createRunProfile(