@codingame/monaco-vscode-testing-service-override 5.2.0 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-testing-service-override",
-  "version": "5.2.0",
+  "version": "6.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@5.2.0",
-    "@codingame/monaco-vscode-terminal-service-override": "5.2.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@6.0.0",
+    "@codingame/monaco-vscode-terminal-service-override": "6.0.0"
   }
 }

package/vscode/src/vs/workbench/contrib/testing/browser/codeCoverageDecorations.js

@@ -1,55 +1,76 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { $, append, clearNode } from 'vscode/vscode/vs/base/browser/dom';
-import { HoverWidget } from 'vscode/vscode/vs/base/browser/ui/hover/hoverWidget';
+import { h, addStandardDisposableListener, EventType, reset } from 'vscode/vscode/vs/base/browser/dom';
+import { ActionViewItem } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { ActionBar, ActionsOrientation } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { renderIcon } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { Action } from 'vscode/vscode/vs/base/common/actions';
 import { mapFindFirst } from 'vscode/vscode/vs/base/common/arraysFind';
-import { assertNever } from 'vscode/vscode/vs/base/common/assert';
+import { assertNever, assert } from 'vscode/vscode/vs/base/common/assert';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
-import { KeyChord } from 'vscode/vscode/vs/base/common/keyCodes';
+import { KeyChord, KeyMod, KeyCode } from 'vscode/vscode/vs/base/common/keyCodes';
 import { Lazy } from 'vscode/vscode/vs/base/common/lazy';
-import { Disposable, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore, toDisposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
 import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
 import { autorun } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
 import { observableFromEvent } from 'vscode/vscode/vs/base/common/observableInternal/utils';
 import 'vscode/vscode/vs/base/common/arrays';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { MarkdownRenderer } from 'vscode/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
+import { isUriComponents, URI } from 'vscode/vscode/vs/base/common/uri';
+import { MouseTargetType, OverlayWidgetPositionPreference } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { EditorOption } from 'vscode/vscode/vs/editor/common/config/editorOptions';
 import { Position } from 'vscode/vscode/vs/editor/common/core/position';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { InjectedTextCursorStops } from 'vscode/vscode/vs/editor/common/model';
-import { HoverOperation } from 'vscode/vscode/vs/editor/contrib/hover/browser/hoverOperation';
 import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
-import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { MenuId, registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView.service';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
+import { KeybindingWeight } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { testingCoverageMissingBranch } from './icons.js';
+import { observableConfigValue } from 'vscode/vscode/vs/platform/observable/common/platformObservableUtils';
+import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
+import { labels, getLabelForItem } from './codeCoverageDisplayUtils.js';
+import { testingCoverageMissingBranch, testingCoverageReport, testingFilterIcon, testingRerunIcon } from './icons.js';
+import { ManagedTestCoverageBars } from './testCoverageBars.js';
+import { TestingConfigKeys, getTestingConfiguration } from '../common/configuration.js';
+import { TestCommandId } from 'vscode/vscode/vs/workbench/contrib/testing/common/constants';
+import { FileCoverage } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverage';
 import { ITestCoverageService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testCoverageService.service';
+import { TestId } from 'vscode/vscode/vs/workbench/contrib/testing/common/testId';
+import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService.service';
+import { DetailType } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
 import { TestingContextKeys } from '../common/testingContextKeys.js';
 
-var CodeCoverageDecorations_1, LineHoverWidget_1;
+var CodeCoverageDecorations_1;
 const _moduleId = "vs/workbench/contrib/testing/browser/codeCoverageDecorations";
 const MAX_HOVERED_LINES = 30;
 const CLASS_HIT = 'coverage-deco-hit';
 const CLASS_MISS = 'coverage-deco-miss';
-const TOGGLE_INLINE_COMMAND_TEXT = ( localizeWithPath(_moduleId, 0, 'Toggle Inline Coverage'));
+const TOGGLE_INLINE_COMMAND_TEXT = ( localizeWithPath(_moduleId, 0, 'Toggle Inline'));
 const TOGGLE_INLINE_COMMAND_ID = 'testing.toggleInlineCoverage';
 const BRANCH_MISS_INDICATOR_CHARS = 4;
 let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
     static { CodeCoverageDecorations_1 = this; }
     static { this.showInline = observableValue('inlineCoverage', false); }
     static { this.fileCoverageDecorations = ( (new WeakMap())); }
-    constructor(editor, instantiationService, coverage, log) {
+    constructor(editor, instantiationService, coverage, configurationService, log) {
         super();
         this.editor = editor;
         this.log = log;
         this.displayedStore = this._register(( (new DisposableStore())));
         this.hoveredStore = this._register(( (new DisposableStore())));
         this.decorationIds = ( (new Map()));
-        this.lineHoverWidget = ( (new Lazy(
-            () => this._register(instantiationService.createInstance(LineHoverWidget, this.editor))
+        this.summaryWidget = ( (new Lazy(
+            () => this._register(instantiationService.createInstance(CoverageToolbarWidget, this.editor))
         )));
         const modelObs = observableFromEvent(editor.onDidChangeModel, () => editor.getModel());
         const configObs = observableFromEvent(editor.onDidChangeConfiguration, i => i);
@@ -62,8 +83,12 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
             if (!model) {
                 return;
             }
-            const file = report.getUri(model.uri);
+            let file = report.getUri(model.uri);
             if (file) {
+                const testFilter = coverage.filterToTest.read(reader);
+                if (testFilter) {
+                    file = file.perTestData?.get(( (testFilter.toString()))) || file;
+                }
                 return file;
             }
             report.didAddCoverage.read(reader);
@@ -78,22 +103,31 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
                 this.clear();
             }
         }));
+        const toolbarEnabled = observableConfigValue(TestingConfigKeys.CoverageToolbarEnabled, true, configurationService);
+        this._register(autorun(reader => {
+            const c = fileCoverage.read(reader);
+            if (c && toolbarEnabled.read(reader)) {
+                this.summaryWidget.value.setCoverage(c);
+            }
+            else {
+                this.summaryWidget.rawValue?.setCoverage(undefined);
+            }
+        }));
         this._register(autorun(reader => {
             const c = fileCoverage.read(reader);
             if (c) {
                 const evt = configObs.read(reader);
-                if (evt?.hasChanged(67 ) !== false) {
+                if (evt?.hasChanged(EditorOption.lineHeight) !== false) {
                     this.updateEditorStyles();
                 }
             }
         }));
         this._register(editor.onMouseMove(e => {
             const model = editor.getModel();
-            if (e.target.type === 3  && model) {
+            if (e.target.type === MouseTargetType.GUTTER_LINE_NUMBERS && model) {
                 this.hoverLineNumber(editor.getModel(), e.target.position.lineNumber);
             }
-            else if (this.lineHoverWidget.hasValue && this.lineHoverWidget.value.getDomNode().contains(e.target.element)) ;
-            else if (CodeCoverageDecorations_1.showInline.get() && e.target.type === 6  && model) {
+            else if (CodeCoverageDecorations_1.showInline.get() && e.target.type === MouseTargetType.CONTENT_TEXT && model) {
                 this.hoverInlineDecoration(model, e.target.position);
             }
             else {
@@ -114,7 +148,7 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
         }));
     }
     updateEditorStyles() {
-        const lineHeight = this.editor.getOption(67 );
+        const lineHeight = this.editor.getOption(EditorOption.lineHeight);
         const { style } = this.editor.getContainerDomNode();
         style.setProperty('--vscode-testing-coverage-lineHeight', `${lineHeight}px`);
     }
@@ -150,7 +184,6 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
         this.hoveredSubject = lineNumber;
         const todo = [{ line: lineNumber, dir: 0 }];
         const toEnable = ( (new Set()));
-        const inlineEnabled = CodeCoverageDecorations_1.showInline.get();
         if (!CodeCoverageDecorations_1.showInline.get()) {
             for (let i = 0; i < todo.length && i < MAX_HOVERED_LINES; i++) {
                 const { line, dir } = todo[i];
@@ -179,14 +212,10 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
                 }
             });
         }
-        if (toEnable.size || inlineEnabled) {
-            this.lineHoverWidget.value.startShowingAt(lineNumber);
-        }
         this.hoveredStore.add(this.editor.onMouseLeave(() => {
             this.hoveredStore.clear();
         }));
         this.hoveredStore.add(toDisposable(() => {
-            this.lineHoverWidget.value.hide();
             this.hoveredSubject = undefined;
             model.changeDecorations(e => {
                 for (const id of toEnable) {
@@ -207,7 +236,7 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
         model.changeDecorations(e => {
             for (const detailRange of details.ranges) {
                 const { metadata: { detail, description }, range, primary } = detailRange;
-                if (detail.type === 2 ) {
+                if (detail.type === DetailType.Branch) {
                     const hits = detail.detail.branches[detail.branch].count;
                     const cls = hits ? CLASS_HIT : CLASS_MISS;
                     const showMissIndicator = !hits && range.isEmpty() && ( (detail.detail.branches.some(b => b.count)));
@@ -238,7 +267,7 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
                     }
                     this.decorationIds.set(e.addDecoration(range, options), { options, applyHoverOptions, detail: detailRange });
                 }
-                else if (detail.type === 1 ) {
+                else if (detail.type === DetailType.Statement) {
                     const cls = detail.count ? CLASS_HIT : CLASS_MISS;
                     const options = {
                         showIfCollapsed: false,
@@ -300,7 +329,8 @@ let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
 CodeCoverageDecorations = CodeCoverageDecorations_1 = ( (__decorate([
     ( (__param(1, IInstantiationService))),
     ( (__param(2, ITestCoverageService))),
-    ( (__param(3, ILogService)))
+    ( (__param(3, IConfigurationService))),
+    ( (__param(4, ILogService)))
 ], CodeCoverageDecorations)));
 const countBadge = (count) => {
     if (count === 0) {
@@ -323,9 +353,9 @@ class CoverageDetailsModel {
             metadata: { detail, description: this.describe(detail, textModel) }
         }))));
         for (const { range, metadata: { detail } } of detailRanges) {
-            if (detail.type === 1  && detail.branches) {
+            if (detail.type === DetailType.Statement && detail.branches) {
                 for (let i = 0; i < detail.branches.length; i++) {
-                    const branch = { type: 2 , branch: i, detail };
+                    const branch = { type: DetailType.Branch, branch: i, detail };
                     detailRanges.push({
                         range: tidyLocation(detail.branches[i].location || Range.fromPositions(range.getEndPosition())),
                         primary: true,
@@ -375,10 +405,10 @@ class CoverageDetailsModel {
         }
     }
     describe(detail, model) {
-        if (detail.type === 0 ) {
+        if (detail.type === DetailType.Declaration) {
             return namedDetailLabel(detail.name, detail);
         }
-        else if (detail.type === 1 ) {
+        else if (detail.type === DetailType.Statement) {
             const text = wrapName(model.getValueInRange(tidyLocation(detail.location)).trim() || `<empty statement>`);
             if (detail.branches?.length) {
                 const covered = detail.branches.filter(b => !!b.count).length;
@@ -395,7 +425,7 @@ class CoverageDetailsModel {
                 return namedDetailLabel(text, detail);
             }
         }
-        else if (detail.type === 2 ) {
+        else if (detail.type === DetailType.Branch) {
             const text = wrapName(model.getValueInRange(tidyLocation(detail.detail.location)).trim() || `<empty statement>`);
             const { count, label } = detail.detail.branches[detail.branch];
             const label2 = label ? wrapInBackticks(label) : `#${detail.branch + 1}`;
@@ -432,26 +462,6 @@ function tidyLocation(location) {
     }
     return location;
 }
-let LineHoverComputer = class LineHoverComputer {
-    constructor(keybindingService) {
-        this.keybindingService = keybindingService;
-        this.line = -1;
-    }
-    computeSync() {
-        const strs = [];
-        const s = ( (new MarkdownString())).appendMarkdown(`[${TOGGLE_INLINE_COMMAND_TEXT}](command:${TOGGLE_INLINE_COMMAND_ID})`);
-        s.isTrusted = true;
-        const binding = this.keybindingService.lookupKeybinding(TOGGLE_INLINE_COMMAND_ID);
-        if (binding) {
-            s.appendText(` (${binding.getLabel()})`);
-        }
-        strs.push(s);
-        return strs;
-    }
-};
-LineHoverComputer = ( (__decorate([
-    ( (__param(0, IKeybindingService)))
-], LineHoverComputer)));
 function wrapInBackticks(str) {
     return '`' + str.replace(/[\n\r`]/g, '') + '`';
 }
@@ -461,97 +471,305 @@ function wrapName(functionNameOrCode) {
     }
     return wrapInBackticks(functionNameOrCode);
 }
-let LineHoverWidget = class LineHoverWidget extends Disposable {
-    static { LineHoverWidget_1 = this; }
-    static { this.ID = 'editor.contrib.testingCoverageLineHoverWidget'; }
-    constructor(editor, instantiationService) {
+let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
+    constructor(editor, configurationService, contextMenuService, testService, keybindingService, commandService, instaService) {
         super();
         this.editor = editor;
-        this.hover = this._register(( (new HoverWidget())));
-        this.renderDisposables = this._register(( (new DisposableStore())));
-        this.computer = instantiationService.createInstance(LineHoverComputer);
-        this.markdownRenderer = this._register(instantiationService.createInstance(MarkdownRenderer, { editor: this.editor }));
-        this.hoverOperation = this._register(( (new HoverOperation(this.editor, this.computer))));
-        this.hover.containerDomNode.classList.add('hidden');
-        this.hoverOperation.onResult(result => {
-            if (result.value.length) {
-                this.render(result.value);
-            }
-            else {
-                this.hide();
+        this.configurationService = configurationService;
+        this.contextMenuService = contextMenuService;
+        this.testService = testService;
+        this.keybindingService = keybindingService;
+        this.commandService = commandService;
+        this.registered = false;
+        this.isRunning = false;
+        this.showStore = this._register(( (new DisposableStore())));
+        this._domNode = h('div.coverage-summary-widget', [
+            h('div', [
+                h('span.bars@bars'),
+                h('span.toolbar@toolbar'),
+            ]),
+        ]);
+        this.bars = this._register(instaService.createInstance(ManagedTestCoverageBars, {
+            compact: false,
+            overall: false,
+            container: this._domNode.bars,
+        }));
+        this.actionBar = this._register(instaService.createInstance(ActionBar, this._domNode.toolbar, {
+            orientation: ActionsOrientation.HORIZONTAL,
+            actionViewItemProvider: (action, options) => {
+                const vm = ( (new CodiconActionViewItem(undefined, action, options)));
+                if (action instanceof ActionWithIcon) {
+                    vm.themeIcon = action.icon;
+                }
+                return vm;
             }
-        });
-        this.editor.addOverlayWidget(this);
+        }));
+        this._register(autorun(reader => {
+            CodeCoverageDecorations.showInline.read(reader);
+            this.setActions();
+        }));
+        this._register(addStandardDisposableListener(this._domNode.root, EventType.CONTEXT_MENU, e => {
+            this.contextMenuService.showContextMenu({
+                menuId: MenuId.StickyScrollContext,
+                getAnchor: () => e,
+            });
+        }));
     }
     getId() {
-        return LineHoverWidget_1.ID;
+        return 'coverage-summary-widget';
     }
     getDomNode() {
-        return this.hover.containerDomNode;
+        return this._domNode.root;
     }
     getPosition() {
-        return null;
+        return {
+            preference: OverlayWidgetPositionPreference.TOP_CENTER,
+            stackOridinal: 9,
+        };
     }
-    dispose() {
-        this.editor.removeOverlayWidget(this);
-        super.dispose();
+    setCoverage(coverage) {
+        this.current = coverage;
+        this.bars.setCoverageInfo(coverage);
+        if (!coverage) {
+            this.hide();
+        }
+        else {
+            this.setActions();
+            this.show();
+        }
     }
-    startShowingAt(lineNumber) {
-        this.hide();
-        const textModel = this.editor.getModel();
-        if (!textModel) {
+    setActions() {
+        this.actionBar.clear();
+        const coverage = this.current;
+        if (!coverage) {
             return;
         }
-        this.computer.line = lineNumber;
-        this.hoverOperation.start(0 );
+        const toggleAction = ( (new ActionWithIcon('toggleInline', CodeCoverageDecorations.showInline.get()
+            ? ( localizeWithPath(_moduleId, 8, 'Hide Inline Coverage'))
+            : ( localizeWithPath(_moduleId, 9, 'Show Inline Coverage')), testingCoverageReport, undefined, () => CodeCoverageDecorations.showInline.set(!CodeCoverageDecorations.showInline.get(), undefined))));
+        const kb = this.keybindingService.lookupKeybinding(TOGGLE_INLINE_COMMAND_ID);
+        if (kb) {
+            toggleAction.tooltip = `${TOGGLE_INLINE_COMMAND_TEXT} (${kb.getLabel()})`;
+        }
+        this.actionBar.push(toggleAction);
+        if (coverage.isForTest) {
+            const testItem = coverage.fromResult.getTestById(( (coverage.isForTest.id.toString())));
+            assert(!!testItem, 'got coverage for an unreported test');
+            this.actionBar.push(( (new ActionWithIcon(
+                'perTestFilter',
+                labels.showingFilterFor(testItem.label),
+                testingFilterIcon,
+                undefined,
+                () => this.commandService.executeCommand(TestCommandId.CoverageFilterToTestInEditor, this.current)
+            ))));
+        }
+        else if (coverage.perTestData?.size) {
+            this.actionBar.push(( (new ActionWithIcon('perTestFilter', ( localizeWithPath(
+                _moduleId,
+                10,
+                "{0} test(s) ran code in this file",
+                coverage.perTestData.size
+            )), testingFilterIcon, undefined, () => this.commandService.executeCommand(TestCommandId.CoverageFilterToTestInEditor, this.current)))));
+        }
+        this.actionBar.push(( (new ActionWithIcon('rerun', ( localizeWithPath(_moduleId, 11, 'Rerun')), testingRerunIcon, !this.isRunning, () => this.rerunTest()))));
     }
-    hide() {
-        this.hoverOperation.cancel();
-        this.hover.containerDomNode.classList.add('hidden');
+    show() {
+        if (this.registered) {
+            return;
+        }
+        this.registered = true;
+        let viewZoneId;
+        const ds = this.showStore;
+        this.editor.addOverlayWidget(this);
+        this.editor.changeViewZones(accessor => {
+            viewZoneId = accessor.addZone({
+                afterLineNumber: 0,
+                afterColumn: 0,
+                domNode: document.createElement('div'),
+                heightInPx: 30,
+                ordinal: -1,
+            });
+        });
+        ds.add(toDisposable(() => {
+            this.registered = false;
+            this.editor.removeOverlayWidget(this);
+            this.editor.changeViewZones(accessor => {
+                accessor.removeZone(viewZoneId);
+            });
+        }));
+        ds.add(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(TestingConfigKeys.CoverageBarThresholds) || e.affectsConfiguration(TestingConfigKeys.CoveragePercent)) {
+                this.setCoverage(this.current);
+            }
+        }));
     }
-    render(elements) {
-        const { hover: h, editor: editor } = this;
-        const fragment = document.createDocumentFragment();
-        for (const msg of elements) {
-            const markdownHoverElement = $('div.hover-row.markdown-hover');
-            const hoverContentsElement = append(markdownHoverElement, $('div.hover-contents'));
-            const renderedContents = this.renderDisposables.add(this.markdownRenderer.render(msg));
-            hoverContentsElement.appendChild(renderedContents.element);
-            fragment.appendChild(markdownHoverElement);
+    rerunTest() {
+        const current = this.current;
+        if (current) {
+            this.isRunning = true;
+            this.setActions();
+            this.testService.runResolvedTests(current.fromResult.request).finally(() => {
+                this.isRunning = false;
+                this.setActions();
+            });
         }
-        clearNode(h.contentsDomNode);
-        h.contentsDomNode.appendChild(fragment);
-        h.containerDomNode.classList.remove('hidden');
-        const editorLayout = editor.getLayoutInfo();
-        const topForLineNumber = editor.getTopForLineNumber(this.computer.line);
-        const editorScrollTop = editor.getScrollTop();
-        const lineHeight = editor.getOption(67 );
-        const nodeHeight = h.containerDomNode.clientHeight;
-        const top = topForLineNumber - editorScrollTop - ((nodeHeight - lineHeight) / 2);
-        const left = editorLayout.lineNumbersLeft + editorLayout.lineNumbersWidth;
-        h.containerDomNode.style.left = `${left}px`;
-        h.containerDomNode.style.top = `${Math.max(Math.round(top), 0)}px`;
+    }
+    hide() {
+        this.showStore.clear();
     }
 };
-LineHoverWidget = LineHoverWidget_1 = ( (__decorate([
-    ( (__param(1, IInstantiationService)))
-], LineHoverWidget)));
+CoverageToolbarWidget = ( (__decorate([
+    ( (__param(1, IConfigurationService))),
+    ( (__param(2, IContextMenuService))),
+    ( (__param(3, ITestService))),
+    ( (__param(4, IKeybindingService))),
+    ( (__param(5, ICommandService))),
+    ( (__param(6, IInstantiationService)))
+], CoverageToolbarWidget)));
 registerAction2(class ToggleInlineCoverage extends Action2 {
     constructor() {
         super({
             id: TOGGLE_INLINE_COMMAND_ID,
-            title: ( localize2WithPath(_moduleId, 8, "Toggle Inline Coverage")),
+            title: ( localize2WithPath(_moduleId, 12, "Show Inline Coverage")),
             category: Categories.Test,
             keybinding: {
-                weight: 200 ,
-                primary: KeyChord(2048  | 85 , 2048  | 1024  | 39 ),
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.Semicolon, KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyI),
             },
-            precondition: TestingContextKeys.isTestCoverageOpen,
+            icon: testingCoverageReport,
+            menu: [
+                { id: MenuId.CommandPalette, when: TestingContextKeys.isTestCoverageOpen },
+                { id: MenuId.EditorTitle, when: ( (ContextKeyExpr.and(
+                    TestingContextKeys.isTestCoverageOpen,
+                     (TestingContextKeys.coverageToolbarEnabled.notEqualsTo(true))
+                ))), group: 'navigation' },
+            ]
         });
     }
     run() {
         CodeCoverageDecorations.showInline.set(!CodeCoverageDecorations.showInline.get(), undefined);
     }
 });
+registerAction2(class ToggleCoverageToolbar extends Action2 {
+    constructor() {
+        super({
+            id: TestCommandId.CoverageToggleToolbar,
+            title: ( localize2WithPath(_moduleId, 13, "Test Coverage Toolbar")),
+            metadata: {
+                description: ( localize2WithPath(_moduleId, 14, 'Toggle the sticky coverage bar in the editor.'))
+            },
+            category: Categories.Test,
+            toggled: {
+                condition: TestingContextKeys.coverageToolbarEnabled,
+            },
+            menu: [
+                { id: MenuId.CommandPalette, when: TestingContextKeys.isTestCoverageOpen },
+                { id: MenuId.StickyScrollContext, when: TestingContextKeys.isTestCoverageOpen },
+                { id: MenuId.EditorTitle, when: TestingContextKeys.isTestCoverageOpen, group: 'coverage@1' },
+            ]
+        });
+    }
+    run(accessor) {
+        const config = accessor.get(IConfigurationService);
+        const value = getTestingConfiguration(config, TestingConfigKeys.CoverageToolbarEnabled);
+        config.updateValue(TestingConfigKeys.CoverageToolbarEnabled, !value);
+    }
+});
+registerAction2(class FilterCoverageToTestInEditor extends Action2 {
+    constructor() {
+        super({
+            id: TestCommandId.CoverageFilterToTestInEditor,
+            title: ( localize2WithPath(_moduleId, 15, "Filter Coverage to Test")),
+            category: Categories.Test,
+            icon: Codicon.filter,
+            toggled: {
+                icon: Codicon.filterFilled,
+                condition: TestingContextKeys.isCoverageFilteredToTest,
+            },
+            menu: [
+                { id: MenuId.EditorTitle, when: ( (ContextKeyExpr.and(
+                    TestingContextKeys.isTestCoverageOpen,
+                     (TestingContextKeys.coverageToolbarEnabled.notEqualsTo(true))
+                ))), group: 'navigation' },
+            ]
+        });
+    }
+    run(accessor, coverageOrUri) {
+        const testCoverageService = accessor.get(ITestCoverageService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const activeEditor = accessor.get(ICodeEditorService).getActiveCodeEditor();
+        let coverage;
+        if (coverageOrUri instanceof FileCoverage) {
+            coverage = coverageOrUri;
+        }
+        else if (isUriComponents(coverageOrUri)) {
+            coverage = testCoverageService.selected.get()?.getUri(( (URI.from(coverageOrUri))));
+        }
+        else {
+            const uri = activeEditor?.getModel()?.uri;
+            coverage = uri && testCoverageService.selected.get()?.getUri(uri);
+        }
+        if (!coverage || !(coverage.isForTest || coverage.perTestData?.size)) {
+            return;
+        }
+        const options = coverage?.perTestData ?? coverage?.isForTest?.parent.perTestData;
+        if (!options) {
+            return;
+        }
+        const tests = [...( (options.values()))];
+        const commonPrefix = TestId.getLengthOfCommonPrefix(tests.length, i => tests[i].isForTest.id);
+        const result = coverage.fromResult;
+        const previousSelection = testCoverageService.filterToTest.get();
+        const items = [
+            { label: labels.allTests, item: undefined },
+            { type: 'separator' },
+            ...( (tests.map(
+                item => ({ label: getLabelForItem(result, item.isForTest.id, commonPrefix), description: labels.percentCoverage(item.tpc), item })
+            ))),
+        ];
+        const scrollTop = activeEditor?.getScrollTop() || 0;
+        const revealScrollCts = ( (new MutableDisposable()));
+        quickInputService.pick(items, {
+            activeItem: items.find((item) => 'item' in item && item.item === coverage),
+            placeHolder: labels.pickShowCoverage,
+            onDidFocus: (entry) => {
+                if (!entry.item) {
+                    revealScrollCts.clear();
+                    activeEditor?.setScrollTop(scrollTop);
+                    testCoverageService.filterToTest.set(undefined, undefined);
+                }
+                else {
+                    const cts = revealScrollCts.value = ( (new CancellationTokenSource()));
+                    entry.item.details(cts.token).then(details => {
+                        const first = details.find(d => d.type === DetailType.Statement);
+                        if (!cts.token.isCancellationRequested && first) {
+                            activeEditor?.revealLineNearTop(first.location instanceof Position ? first.location.lineNumber : first.location.startLineNumber);
+                        }
+                    }, () => { });
+                    testCoverageService.filterToTest.set(entry.item.isForTest.id, undefined);
+                }
+            },
+        }).then(selected => {
+            if (!selected) {
+                activeEditor?.setScrollTop(scrollTop);
+            }
+            revealScrollCts.dispose();
+            testCoverageService.filterToTest.set(selected ? selected.item?.isForTest.id : previousSelection, undefined);
+        });
+    }
+});
+class ActionWithIcon extends Action {
+    constructor(id, title, icon, enabled, run) {
+        super(id, title, undefined, enabled, run);
+        this.icon = icon;
+    }
+}
+class CodiconActionViewItem extends ActionViewItem {
+    updateLabel() {
+        if (this.options.label && this.label && this.themeIcon) {
+            reset(this.label, renderIcon(this.themeIcon), this.action.label);
+        }
+    }
+}
 
 export { CodeCoverageDecorations, CoverageDetailsModel };