testing: rename FunctionCoverage -> DeclarationCoverage for finalization (microsoft#204667)

Author: connor4312

src/vs/workbench/api/common/extHost.api.impl.ts

@@ -1615,7 +1615,6 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			TestResultState: extHostTypes.TestResultState,
 			TestRunRequest: extHostTypes.TestRunRequest,
 			TestMessage: extHostTypes.TestMessage,
-			TestMessage2: extHostTypes.TestMessage, // back compat for Oct 2023
 			TestTag: extHostTypes.TestTag,
 			TestRunProfileKind: extHostTypes.TestRunProfileKind,
 			TextSearchCompleteMessageType: TextSearchCompleteMessageType,
@@ -1625,7 +1624,8 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 			FileCoverage: extHostTypes.FileCoverage,
 			StatementCoverage: extHostTypes.StatementCoverage,
 			BranchCoverage: extHostTypes.BranchCoverage,
-			FunctionCoverage: extHostTypes.FunctionCoverage,
+			DeclarationCoverage: extHostTypes.DeclarationCoverage,
+			FunctionCoverage: extHostTypes.DeclarationCoverage,  // back compat for Feb 2024
 			WorkspaceTrustState: extHostTypes.WorkspaceTrustState,
 			LanguageStatusSeverity: extHostTypes.LanguageStatusSeverity,
 			QuickPickItemKind: extHostTypes.QuickPickItemKind,

src/vs/workbench/api/common/extHostTypeConverters.ts

@@ -2021,7 +2021,7 @@ export namespace TestCoverage {
 			};
 		} else {
 			return {
-				type: DetailType.Function,
+				type: DetailType.Declaration,
 				name: coverage.name,
 				count: coverage.executed,
 				location: fromLocation(coverage.location),
@@ -2034,7 +2034,7 @@ export namespace TestCoverage {
 			uri: coverage.uri,
 			statement: fromCoveredCount(coverage.statementCoverage),
 			branch: coverage.branchCoverage && fromCoveredCount(coverage.branchCoverage),
-			function: coverage.functionCoverage && fromCoveredCount(coverage.functionCoverage),
+			declaration: coverage.declarationCoverage && fromCoveredCount(coverage.declarationCoverage),
 			details: coverage.detailedCoverage?.map(fromDetailed),
 		};
 	}

src/vs/workbench/api/common/extHostTypes.ts

@@ -3970,7 +3970,7 @@ export class FileCoverage implements vscode.FileCoverage {
 	public static fromDetails(uri: vscode.Uri, details: vscode.DetailedCoverage[]): vscode.FileCoverage {
 		const statements = new CoveredCount(0, 0);
 		const branches = new CoveredCount(0, 0);
-		const fn = new CoveredCount(0, 0);
+		const decl = new CoveredCount(0, 0);
 
 		for (const detail of details) {
 			if ('branches' in detail) {
@@ -3982,16 +3982,16 @@ export class FileCoverage implements vscode.FileCoverage {
 					branches.covered += branch.executed ? 1 : 0;
 				}
 			} else {
-				fn.total += 1;
-				fn.covered += detail.executed ? 1 : 0;
+				decl.total += 1;
+				decl.covered += detail.executed ? 1 : 0;
 			}
 		}
 
 		const coverage = new FileCoverage(
 			uri,
 			statements,
 			branches.total > 0 ? branches : undefined,
-			fn.total > 0 ? fn : undefined,
+			decl.total > 0 ? decl : undefined,
 		);
 
 		coverage.detailedCoverage = details;
@@ -4005,11 +4005,11 @@ export class FileCoverage implements vscode.FileCoverage {
 		public readonly uri: vscode.Uri,
 		public statementCoverage: vscode.CoveredCount,
 		public branchCoverage?: vscode.CoveredCount,
-		public functionCoverage?: vscode.CoveredCount,
+		public declarationCoverage?: vscode.CoveredCount,
 	) {
 		validateCC(statementCoverage);
 		validateCC(branchCoverage);
-		validateCC(functionCoverage);
+		validateCC(declarationCoverage);
 	}
 }
 
@@ -4037,7 +4037,7 @@ export class BranchCoverage implements vscode.BranchCoverage {
 	) { }
 }
 
-export class FunctionCoverage implements vscode.FunctionCoverage {
+export class DeclarationCoverage implements vscode.DeclarationCoverage {
 	// back compat until finalization:
 	get executionCount() { return +this.executed; }
 	set executionCount(n: number) { this.executed = n; }

src/vs/workbench/contrib/testing/browser/codeCoverageDecorations.ts

@@ -366,7 +366,7 @@ export class CoverageDetailsModel {
 
 		//#region decoration generation
 		// Coverage from a provider can have a range that contains smaller ranges,
-		// such as a function declarationt that has nested statements. In this we
+		// such as a function declaration that has nested statements. In this we
 		// make sequential, non-overlapping ranges for each detail for display in
 		// the editor without ugly overlaps.
 		const detailRanges: DetailRange[] = details.map(detail => ({
@@ -445,8 +445,8 @@ export class CoverageDetailsModel {
 
 	/** Gets the markdown description for the given detail */
 	public describe(detail: CoverageDetailsWithBranch, model: ITextModel): IMarkdownString | undefined {
-		if (detail.type === DetailType.Function) {
-			return new MarkdownString().appendMarkdown(localize('coverage.fnExecutedCount', 'Function `{0}` was executed {1} time(s).', detail.name, detail.count));
+		if (detail.type === DetailType.Declaration) {
+			return new MarkdownString().appendMarkdown(localize('coverage.declExecutedCount', '`{0}` was executed {1} time(s).', detail.name, detail.count));
 		} else if (detail.type === DetailType.Statement) {
 			const text = wrapName(model.getValueInRange(tidyLocation(detail.location)).trim() || `<empty statement>`);
 			const str = new MarkdownString();

src/vs/workbench/contrib/testing/browser/testCoverageBars.ts

@@ -35,7 +35,7 @@ export interface TestCoverageBarsOptions {
 }
 
 /** Type that can be used to render coverage bars */
-export type CoverageBarSource = Pick<AbstractFileCoverage, 'statement' | 'branch' | 'function'>;
+export type CoverageBarSource = Pick<AbstractFileCoverage, 'statement' | 'branch' | 'declaration'>;
 
 export class ManagedTestCoverageBars extends Disposable {
 	private _coverage?: CoverageBarSource;
@@ -142,7 +142,7 @@ export class ManagedTestCoverageBars extends Disposable {
 			renderBar(el.tpcBar, overallStat, false, thresholds);
 		} else {
 			renderBar(el.statement, percent(coverage.statement), coverage.statement.total === 0, thresholds);
-			renderBar(el.function, coverage.function && percent(coverage.function), coverage.function?.total === 0, thresholds);
+			renderBar(el.function, coverage.declaration && percent(coverage.declaration), coverage.declaration?.total === 0, thresholds);
 			renderBar(el.branch, coverage.branch && percent(coverage.branch), coverage.branch?.total === 0, thresholds);
 		}
 	}
@@ -196,11 +196,11 @@ const calculateDisplayedStat = (coverage: CoverageBarSource, method: TestingDisp
 		case TestingDisplayedCoveragePercent.Minimum: {
 			let value = percent(coverage.statement);
 			if (coverage.branch) { value = Math.min(value, percent(coverage.branch)); }
-			if (coverage.function) { value = Math.min(value, percent(coverage.function)); }
+			if (coverage.declaration) { value = Math.min(value, percent(coverage.declaration)); }
 			return value;
 		}
 		case TestingDisplayedCoveragePercent.TotalCoverage:
-			return getTotalCoveragePercent(coverage.statement, coverage.branch, coverage.function);
+			return getTotalCoveragePercent(coverage.statement, coverage.branch, coverage.declaration);
 		default:
 			assertNever(method);
 	}
@@ -219,7 +219,7 @@ const displayPercent = (value: number, precision = 2) => {
 };
 
 const stmtCoverageText = (coverage: CoverageBarSource) => localize('statementCoverage', '{0}/{1} statements covered ({2})', coverage.statement.covered, coverage.statement.total, displayPercent(percent(coverage.statement)));
-const fnCoverageText = (coverage: CoverageBarSource) => coverage.function && localize('functionCoverage', '{0}/{1} functions covered ({2})', coverage.function.covered, coverage.function.total, displayPercent(percent(coverage.function)));
+const fnCoverageText = (coverage: CoverageBarSource) => coverage.declaration && localize('functionCoverage', '{0}/{1} functions covered ({2})', coverage.declaration.covered, coverage.declaration.total, displayPercent(percent(coverage.declaration)));
 const branchCoverageText = (coverage: CoverageBarSource) => coverage.branch && localize('branchCoverage', '{0}/{1} branches covered ({2})', coverage.branch.covered, coverage.branch.total, displayPercent(percent(coverage.branch)));
 
 const getOverallHoverText = (coverage: CoverageBarSource) => new MarkdownString([

src/vs/workbench/contrib/testing/browser/testCoverageView.ts

@@ -44,7 +44,7 @@ import { CoverageBarSource, ManagedTestCoverageBars } from 'vs/workbench/contrib
 import { TestCommandId, Testing } from 'vs/workbench/contrib/testing/common/constants';
 import { ComputedFileCoverage, FileCoverage, TestCoverage, getTotalCoveragePercent } from 'vs/workbench/contrib/testing/common/testCoverage';
 import { ITestCoverageService } from 'vs/workbench/contrib/testing/common/testCoverageService';
-import { CoverageDetails, DetailType, ICoveredCount, IFunctionCoverage, TestResultState } from 'vs/workbench/contrib/testing/common/testTypes';
+import { CoverageDetails, DetailType, ICoveredCount, IDeclarationCoverage, TestResultState } from 'vs/workbench/contrib/testing/common/testTypes';
 import { ACTIVE_GROUP, IEditorService, SIDE_GROUP } from 'vs/workbench/services/editor/common/editorService';
 
 const enum CoverageSortOrder {
@@ -97,10 +97,10 @@ export class TestCoverageView extends ViewPane {
 
 let fnNodeId = 0;
 
-class FunctionCoverageNode {
+class DeclarationCoverageNode {
 	public readonly id = String(fnNodeId++);
 	public readonly containedDetails = new Set<CoverageDetails>();
-	public readonly children: FunctionCoverageNode[] = [];
+	public readonly children: DeclarationCoverageNode[] = [];
 
 	public get hits() {
 		return this.data.count;
@@ -121,7 +121,7 @@ class FunctionCoverageNode {
 
 	constructor(
 		public readonly uri: URI,
-		private readonly data: IFunctionCoverage,
+		private readonly data: IDeclarationCoverage,
 		details: readonly CoverageDetails[],
 	) {
 		if (data.location instanceof Range) {
@@ -172,11 +172,11 @@ class FunctionCoverageNode {
 	}
 }
 
-class RevealUncoveredFunctions {
+class RevealUncoveredDeclarations {
 	public readonly id = String(fnNodeId++);
 
 	public get label() {
-		return localize('functionsWithoutCoverage', "{0} functions without coverage...", this.n);
+		return localize('functionsWithoutCoverage', "{0} declarations without coverage...", this.n);
 	}
 
 	constructor(public readonly n: number) { }
@@ -189,12 +189,12 @@ class LoadingDetails {
 
 /** Type of nodes returned from {@link TestCoverage}. Note: value is *always* defined. */
 type TestCoverageFileNode = IPrefixTreeNode<ComputedFileCoverage | FileCoverage>;
-type CoverageTreeElement = TestCoverageFileNode | FunctionCoverageNode | LoadingDetails | RevealUncoveredFunctions;
+type CoverageTreeElement = TestCoverageFileNode | DeclarationCoverageNode | LoadingDetails | RevealUncoveredDeclarations;
 
 const isFileCoverage = (c: CoverageTreeElement): c is TestCoverageFileNode => typeof c === 'object' && 'value' in c;
-const isFunctionCoverage = (c: CoverageTreeElement): c is FunctionCoverageNode => c instanceof FunctionCoverageNode;
-const shouldShowFunctionDetailsOnExpand = (c: CoverageTreeElement): c is IPrefixTreeNode<FileCoverage> =>
-	isFileCoverage(c) && c.value instanceof FileCoverage && !!c.value.function?.total;
+const isDeclarationCoverage = (c: CoverageTreeElement): c is DeclarationCoverageNode => c instanceof DeclarationCoverageNode;
+const shouldShowDeclDetailsOnExpand = (c: CoverageTreeElement): c is IPrefixTreeNode<FileCoverage> =>
+	isFileCoverage(c) && c.value instanceof FileCoverage && !!c.value.declaration?.total;
 
 class TestCoverageTree extends Disposable {
 	private readonly tree: WorkbenchCompressibleObjectTree<CoverageTreeElement, void>;
@@ -215,7 +215,7 @@ class TestCoverageTree extends Disposable {
 			new TestCoverageTreeListDelegate(),
 			[
 				instantiationService.createInstance(FileCoverageRenderer, labels),
-				instantiationService.createInstance(FunctionCoverageRenderer),
+				instantiationService.createInstance(DeclarationCoverageRenderer),
 				instantiationService.createInstance(BasicRenderer),
 			],
 			{
@@ -256,7 +256,7 @@ class TestCoverageTree extends Disposable {
 		this._register(this.tree);
 		this._register(this.tree.onDidChangeCollapseState(e => {
 			const el = e.node.element;
-			if (!e.node.collapsed && !e.node.children.length && el && shouldShowFunctionDetailsOnExpand(el)) {
+			if (!e.node.collapsed && !e.node.children.length && el && shouldShowDeclDetailsOnExpand(el)) {
 				if (el.value!.hasSynchronousDetails) {
 					this.tree.setChildren(el, [{ element: new LoadingDetails(), incompressible: true }]);
 				}
@@ -270,7 +270,7 @@ class TestCoverageTree extends Disposable {
 			if (e.element) {
 				if (isFileCoverage(e.element) && !e.element.children?.size) {
 					resource = e.element.value!.uri;
-				} else if (isFunctionCoverage(e.element)) {
+				} else if (isDeclarationCoverage(e.element)) {
 					resource = e.element.uri;
 					selection = e.element.location;
 				}
@@ -310,7 +310,7 @@ class TestCoverageTree extends Disposable {
 				incompressible: isFile,
 				collapsed: isFile,
 				// directories can be expanded, and items with function info can be expanded
-				collapsible: !isFile || !!file.value?.function?.total,
+				collapsible: !isFile || !!file.value?.declaration?.total,
 				children: file.children && Iterable.map(file.children?.values(), toChild)
 			};
 		};
@@ -327,13 +327,13 @@ class TestCoverageTree extends Disposable {
 			return; // avoid any issues if the tree changes in the meanwhile
 		}
 
-		const functions: FunctionCoverageNode[] = [];
+		const decl: DeclarationCoverageNode[] = [];
 		for (const fn of details) {
-			if (fn.type !== DetailType.Function) {
+			if (fn.type !== DetailType.Declaration) {
 				continue;
 			}
 
-			let arr = functions;
+			let arr = decl;
 			while (true) {
 				const parent = arr.find(p => p.containedDetails.has(fn));
 				if (parent) {
@@ -343,18 +343,18 @@ class TestCoverageTree extends Disposable {
 				}
 			}
 
-			arr.push(new FunctionCoverageNode(el.value!.uri, fn, details));
+			arr.push(new DeclarationCoverageNode(el.value!.uri, fn, details));
 		}
 
-		const makeChild = (fn: FunctionCoverageNode): ICompressedTreeElement<CoverageTreeElement> => ({
+		const makeChild = (fn: DeclarationCoverageNode): ICompressedTreeElement<CoverageTreeElement> => ({
 			element: fn,
 			incompressible: true,
 			collapsed: true,
 			collapsible: fn.children.length > 0,
 			children: fn.children.map(makeChild)
 		});
 
-		this.tree.setChildren(el, functions.map(makeChild));
+		this.tree.setChildren(el, decl.map(makeChild));
 	}
 }
 
@@ -367,10 +367,10 @@ class TestCoverageTreeListDelegate implements IListVirtualDelegate<CoverageTreeE
 		if (isFileCoverage(element)) {
 			return FileCoverageRenderer.ID;
 		}
-		if (isFunctionCoverage(element)) {
-			return FunctionCoverageRenderer.ID;
+		if (isDeclarationCoverage(element)) {
+			return DeclarationCoverageRenderer.ID;
 		}
-		if (element instanceof LoadingDetails || element instanceof RevealUncoveredFunctions) {
+		if (element instanceof LoadingDetails || element instanceof RevealUncoveredDeclarations) {
 			return BasicRenderer.ID;
 		}
 		assertNever(element);
@@ -389,7 +389,7 @@ class Sorter implements ITreeSorter<CoverageTreeElement> {
 				case CoverageSortOrder.Coverage:
 					return b.value!.tpc - a.value!.tpc;
 			}
-		} else if (isFunctionCoverage(a) && isFunctionCoverage(b)) {
+		} else if (isDeclarationCoverage(a) && isDeclarationCoverage(b)) {
 			switch (order) {
 				case CoverageSortOrder.Location:
 					return Position.compare(
@@ -474,24 +474,24 @@ class FileCoverageRenderer implements ICompressibleTreeRenderer<CoverageTreeElem
 	}
 }
 
-interface FunctionTemplateData {
+interface DeclarationTemplateData {
 	container: HTMLElement;
 	bars: ManagedTestCoverageBars;
 	templateDisposables: DisposableStore;
 	icon: HTMLElement;
 	label: HTMLElement;
 }
 
-class FunctionCoverageRenderer implements ICompressibleTreeRenderer<CoverageTreeElement, FuzzyScore, FunctionTemplateData> {
+class DeclarationCoverageRenderer implements ICompressibleTreeRenderer<CoverageTreeElement, FuzzyScore, DeclarationTemplateData> {
 	public static readonly ID = 'N';
-	public readonly templateId = FunctionCoverageRenderer.ID;
+	public readonly templateId = DeclarationCoverageRenderer.ID;
 
 	constructor(
 		@IInstantiationService private readonly instantiationService: IInstantiationService,
 	) { }
 
 	/** @inheritdoc */
-	public renderTemplate(container: HTMLElement): FunctionTemplateData {
+	public renderTemplate(container: HTMLElement): DeclarationTemplateData {
 		const templateDisposables = new DisposableStore();
 		container.classList.add('test-coverage-list-item');
 		const icon = dom.append(container, dom.$('.state'));
@@ -507,21 +507,21 @@ class FunctionCoverageRenderer implements ICompressibleTreeRenderer<CoverageTree
 	}
 
 	/** @inheritdoc */
-	public renderElement(node: ITreeNode<CoverageTreeElement, FuzzyScore>, _index: number, templateData: FunctionTemplateData): void {
-		this.doRender(node.element as FunctionCoverageNode, templateData, node.filterData);
+	public renderElement(node: ITreeNode<CoverageTreeElement, FuzzyScore>, _index: number, templateData: DeclarationTemplateData): void {
+		this.doRender(node.element as DeclarationCoverageNode, templateData, node.filterData);
 	}
 
 	/** @inheritdoc */
-	public renderCompressedElements(node: ITreeNode<ICompressedTreeNode<CoverageTreeElement>, FuzzyScore>, _index: number, templateData: FunctionTemplateData): void {
-		this.doRender(node.element.elements[node.element.elements.length - 1] as FunctionCoverageNode, templateData, node.filterData);
+	public renderCompressedElements(node: ITreeNode<ICompressedTreeNode<CoverageTreeElement>, FuzzyScore>, _index: number, templateData: DeclarationTemplateData): void {
+		this.doRender(node.element.elements[node.element.elements.length - 1] as DeclarationCoverageNode, templateData, node.filterData);
 	}
 
-	public disposeTemplate(templateData: FunctionTemplateData) {
+	public disposeTemplate(templateData: DeclarationTemplateData) {
 		templateData.templateDisposables.dispose();
 	}
 
 	/** @inheritdoc */
-	private doRender(element: FunctionCoverageNode, templateData: FunctionTemplateData, _filterData: FuzzyScore | undefined) {
+	private doRender(element: DeclarationCoverageNode, templateData: DeclarationTemplateData, _filterData: FuzzyScore | undefined) {
 		const covered = !!element.hits;
 		const icon = covered ? testingWasCovered : testingStatesToIcons.get(TestResultState.Unset);
 		templateData.container.classList.toggle('not-covered', !covered);
@@ -552,7 +552,7 @@ class BasicRenderer implements ICompressibleTreeRenderer<CoverageTreeElement, Fu
 	}
 
 	private renderInner(element: CoverageTreeElement, container: HTMLElement) {
-		container.innerText = (element as RevealUncoveredFunctions | LoadingDetails).label;
+		container.innerText = (element as RevealUncoveredDeclarations | LoadingDetails).label;
 	}
 }
 
@@ -585,9 +585,9 @@ registerAction2(class TestCoverageChangeSortingAction extends ViewAction<TestCov
 		const disposables = new DisposableStore();
 		const quickInput = disposables.add(accessor.get(IQuickInputService).createQuickPick<Item>());
 		const items: Item[] = [
-			{ label: localize('testing.coverageSortByLocation', 'Sort by Location'), value: CoverageSortOrder.Location, description: localize('testing.coverageSortByLocationDescription', 'Files are sorted alphabetically, functions are sorted by position') },
-			{ label: localize('testing.coverageSortByCoverage', 'Sort by Coverage'), value: CoverageSortOrder.Coverage, description: localize('testing.coverageSortByCoverageDescription', 'Files and functions are sorted by total coverage') },
-			{ label: localize('testing.coverageSortByName', 'Sort by Name'), value: CoverageSortOrder.Name, description: localize('testing.coverageSortByNameDescription', 'Files and functions are sorted alphabetically') },
+			{ label: localize('testing.coverageSortByLocation', 'Sort by Location'), value: CoverageSortOrder.Location, description: localize('testing.coverageSortByLocationDescription', 'Files are sorted alphabetically, declarations are sorted by position') },
+			{ label: localize('testing.coverageSortByCoverage', 'Sort by Coverage'), value: CoverageSortOrder.Coverage, description: localize('testing.coverageSortByCoverageDescription', 'Files and declarations are sorted by total coverage') },
+			{ label: localize('testing.coverageSortByName', 'Sort by Name'), value: CoverageSortOrder.Name, description: localize('testing.coverageSortByNameDescription', 'Files and declarations are sorted alphabetically') },
 		];
 
 		quickInput.placeholder = localize('testing.coverageSortPlaceholder', 'Sort the Test Coverage view...');