@codingame/monaco-vscode-testing-service-override 7.1.0 → 7.1.1

package/package.json

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

package/vscode/src/vs/workbench/contrib/debug/browser/callStackWidget.js

@@ -0,0 +1,481 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { h, addDisposableListener, clearNode } from 'vscode/vscode/vs/base/browser/dom';
+import { Button } from 'vscode/vscode/vs/base/browser/ui/button/button';
+import { assertNever } 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 { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, DisposableStore, toDisposable } 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, autorunWithStore } from 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import 'vscode/vscode/vs/base/common/observableInternal/utils';
+import 'vscode/vscode/vs/base/common/arrays';
+import { Constants } from 'vscode/vscode/vs/base/common/uint';
+import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import './media/callStackWidget.css.js';
+import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
+import { CodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { EmbeddedCodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { localize, localize2 } from 'vscode/vscode/vs/nls';
+import { createActionViewItem } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuWorkbenchToolBar } from 'vscode/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId, registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { TextEditorSelectionRevealType } from 'vscode/vscode/vs/platform/editor/common/editor';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.service';
+import { WorkbenchList } from 'vscode/vscode/vs/platform/list/browser/listService';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
+import { defaultButtonStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import { ResourceLabel } from 'vscode/vscode/vs/workbench/browser/labels';
+import { makeStackFrameColumnDecoration, TOP_STACK_FRAME_DECORATION } from 'vscode/vscode/vs/workbench/contrib/debug/browser/callStackEditorContribution';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+
+var FrameCodeRenderer_1, SkippedRenderer_1;
+class CallStackFrame {
+    constructor(name, source, line = 1, column = 1) {
+        this.name = name;
+        this.source = source;
+        this.line = line;
+        this.column = column;
+    }
+}
+class SkippedCallFrames {
+    constructor(label, load) {
+        this.label = label;
+        this.load = load;
+    }
+}
+class CustomStackFrame {
+    constructor() {
+        this.showHeader = observableValue('CustomStackFrame.showHeader', true);
+    }
+}
+class WrappedCallStackFrame extends CallStackFrame {
+    constructor(original) {
+        super(original.name, original.source, original.line, original.column);
+        this.editorHeight = observableValue('WrappedCallStackFrame.height', 100);
+        this.collapsed = observableValue('WrappedCallStackFrame.collapsed', false);
+        this.height = derived(reader => {
+            return this.collapsed.read(reader) ? HEADER_HEIGHT : HEADER_HEIGHT + this.editorHeight.read(reader);
+        });
+    }
+}
+class WrappedCustomStackFrame {
+    constructor(original) {
+        this.original = original;
+        this.collapsed = observableValue('WrappedCallStackFrame.collapsed', false);
+        this.height = derived(reader => {
+            const headerHeight = this.original.showHeader.read(reader) ? HEADER_HEIGHT : 0;
+            return this.collapsed.read(reader) ? headerHeight : headerHeight + this.original.height.read(reader);
+        });
+    }
+}
+const WIDGET_CLASS_NAME = 'multiCallStackWidget';
+let CallStackWidget = class CallStackWidget extends Disposable {
+    constructor(container, containingEditor, instantiationService) {
+        super();
+        this.layoutEmitter = this._register(( (new Emitter())));
+        this.currentFramesDs = this._register(( (new DisposableStore())));
+        container.classList.add(WIDGET_CLASS_NAME);
+        this._register(toDisposable(() => container.classList.remove(WIDGET_CLASS_NAME)));
+        this.list = this._register(instantiationService.createInstance(WorkbenchList, 'TestResultStackWidget', container, ( (new StackDelegate())), [
+            instantiationService.createInstance(FrameCodeRenderer, containingEditor, this.layoutEmitter.event),
+            instantiationService.createInstance(MissingCodeRenderer),
+            instantiationService.createInstance(CustomRenderer),
+            instantiationService.createInstance(SkippedRenderer, (i) => this.loadFrame(i)),
+        ], {
+            multipleSelectionSupport: false,
+            mouseSupport: false,
+            keyboardSupport: false,
+            accessibilityProvider: instantiationService.createInstance(StackAccessibilityProvider),
+        }));
+    }
+    setFrames(frames) {
+        this.currentFramesDs.clear();
+        this.cts = ( (new CancellationTokenSource()));
+        this._register(toDisposable(() => this.cts.dispose(true)));
+        this.list.splice(0, this.list.length, this.mapFrames(frames));
+    }
+    layout(height, width) {
+        this.list.layout(height, width);
+        this.layoutEmitter.fire();
+    }
+    async loadFrame(replacing) {
+        if (!this.cts) {
+            return;
+        }
+        const frames = await replacing.load(this.cts.token);
+        if (this.cts.token.isCancellationRequested) {
+            return;
+        }
+        const index = this.list.indexOf(replacing);
+        this.list.splice(index, 1, this.mapFrames(frames));
+    }
+    mapFrames(frames) {
+        const result = [];
+        for (const frame of frames) {
+            if (frame instanceof SkippedCallFrames) {
+                result.push(frame);
+                continue;
+            }
+            const wrapped = frame instanceof CustomStackFrame
+                ? ( (new WrappedCustomStackFrame(frame))) : ( (new WrappedCallStackFrame(frame)));
+            result.push(wrapped);
+            this.currentFramesDs.add(autorun(reader => {
+                const height = wrapped.height.read(reader);
+                const idx = this.list.indexOf(wrapped);
+                if (idx !== -1) {
+                    this.list.updateElementHeight(idx, height);
+                }
+            }));
+        }
+        return result;
+    }
+};
+CallStackWidget = ( (__decorate([
+    ( (__param(2, IInstantiationService)))
+], CallStackWidget)));
+let StackAccessibilityProvider = class StackAccessibilityProvider {
+    constructor(labelService) {
+        this.labelService = labelService;
+    }
+    getAriaLabel(e) {
+        if (e instanceof SkippedCallFrames) {
+            return e.label;
+        }
+        if (e instanceof WrappedCustomStackFrame) {
+            return e.original.label;
+        }
+        if (e instanceof CallStackFrame) {
+            if (e.source && e.line) {
+                return ( localize(
+                    10726,
+                    '{0}, line {1} in {2}',
+                    e.name,
+                    e.line,
+                    this.labelService.getUriLabel(e.source, { relative: true })
+                ));
+            }
+            return e.name;
+        }
+        assertNever();
+    }
+    getWidgetAriaLabel() {
+        return ( localize(10727, 'Stack Trace'));
+    }
+};
+StackAccessibilityProvider = ( (__decorate([
+    ( (__param(0, ILabelService)))
+], StackAccessibilityProvider)));
+class StackDelegate {
+    getHeight(element) {
+        if (element instanceof CallStackFrame || element instanceof WrappedCustomStackFrame) {
+            return element.height.get();
+        }
+        if (element instanceof SkippedCallFrames) {
+            return 50;
+        }
+        assertNever();
+    }
+    getTemplateId(element) {
+        if (element instanceof CallStackFrame) {
+            return element.source ? FrameCodeRenderer.templateId : MissingCodeRenderer.templateId;
+        }
+        if (element instanceof SkippedCallFrames) {
+            return SkippedRenderer.templateId;
+        }
+        if (element instanceof WrappedCustomStackFrame) {
+            return CustomRenderer.templateId;
+        }
+        assertNever();
+    }
+}
+const editorOptions = {
+    scrollBeyondLastLine: false,
+    scrollbar: {
+        vertical: 'hidden',
+        horizontal: 'hidden',
+        handleMouseWheel: false,
+        useShadows: false,
+    },
+    overviewRulerLanes: 0,
+    fixedOverflowWidgets: true,
+    overviewRulerBorder: false,
+    stickyScroll: { enabled: false },
+    minimap: { enabled: false },
+    readOnly: true,
+    automaticLayout: false,
+};
+const makeFrameElements = () => h('div.multiCallStackFrame', [
+    h('div.header@header', [
+        h('div.collapse-button@collapseButton'),
+        h('div.title.show-file-icons@title'),
+        h('div.actions@actions'),
+    ]),
+    h('div.editorParent', [
+        h('div.editorContainer@editor'),
+    ])
+]);
+const HEADER_HEIGHT = 32;
+let AbstractFrameRenderer = class AbstractFrameRenderer {
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+    }
+    renderTemplate(container) {
+        const elements = makeFrameElements();
+        container.appendChild(elements.root);
+        const templateStore = ( (new DisposableStore()));
+        container.classList.add('multiCallStackFrameContainer');
+        templateStore.add(toDisposable(() => {
+            container.classList.remove('multiCallStackFrameContainer');
+            elements.root.remove();
+        }));
+        const label = templateStore.add(this.instantiationService.createInstance(ResourceLabel, elements.title, {}));
+        const collapse = templateStore.add(( (new Button(elements.collapseButton, {}))));
+        const contentId = generateUuid();
+        elements.editor.id = contentId;
+        elements.editor.role = 'region';
+        elements.collapseButton.setAttribute('aria-controls', contentId);
+        return this.finishRenderTemplate({
+            container,
+            decorations: [],
+            elements,
+            label,
+            collapse,
+            elementStore: templateStore.add(( (new DisposableStore()))),
+            templateStore,
+        });
+    }
+    renderElement(element, index, template, height) {
+        const { elementStore } = template;
+        elementStore.clear();
+        const item = element;
+        this.setupCollapseButton(item, template);
+    }
+    setupCollapseButton(item, { elementStore, elements, collapse }) {
+        elementStore.add(autorun(reader => {
+            collapse.element.className = '';
+            const collapsed = item.collapsed.read(reader);
+            collapse.icon = collapsed ? Codicon.chevronRight : Codicon.chevronDown;
+            collapse.element.ariaExpanded = String(!collapsed);
+            elements.root.classList.toggle('collapsed', collapsed);
+        }));
+        elementStore.add(collapse.onDidClick(() => {
+            item.collapsed.set(!item.collapsed.get(), undefined);
+        }));
+    }
+    disposeElement(element, index, templateData, height) {
+        templateData.elementStore.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.templateStore.dispose();
+    }
+};
+AbstractFrameRenderer = ( (__decorate([
+    ( (__param(0, IInstantiationService)))
+], AbstractFrameRenderer)));
+const CONTEXT_LINES = 2;
+let FrameCodeRenderer = class FrameCodeRenderer extends AbstractFrameRenderer {
+    static { FrameCodeRenderer_1 = this; }
+    static { this.templateId = 'f'; }
+    constructor(containingEditor, onLayout, modelService, editorService, instantiationService) {
+        super(instantiationService);
+        this.containingEditor = containingEditor;
+        this.onLayout = onLayout;
+        this.modelService = modelService;
+        this.editorService = editorService;
+        this.templateId = FrameCodeRenderer_1.templateId;
+    }
+    finishRenderTemplate(data) {
+        const editor = this.containingEditor
+            ? this.instantiationService.createInstance(EmbeddedCodeEditorWidget, data.elements.editor, editorOptions, { isSimpleWidget: true }, this.containingEditor)
+            : this.instantiationService.createInstance(CodeEditorWidget, data.elements.editor, editorOptions, { isSimpleWidget: true });
+        data.templateStore.add(editor);
+        const toolbar = data.templateStore.add(this.instantiationService.createInstance(MenuWorkbenchToolBar, data.elements.actions, MenuId.DebugCallStackToolbar, {
+            menuOptions: { shouldForwardArgs: true },
+            actionViewItemProvider: (action, options) => createActionViewItem(this.instantiationService, action, options),
+        }));
+        return { ...data, editor, toolbar };
+    }
+    renderElement(element, index, template, height) {
+        super.renderElement(element, index, template, height);
+        const { elementStore, editor } = template;
+        const item = element;
+        const uri = item.source;
+        template.label.element.setFile(uri);
+        template.elements.title.role = 'link';
+        elementStore.add(addDisposableListener(template.elements.title, 'click', e => {
+            this.editorService.openCodeEditor({
+                resource: uri,
+                options: {
+                    selection: Range.fromPositions({
+                        column: item.column ?? 1,
+                        lineNumber: item.line ?? 1,
+                    }),
+                    selectionRevealType: TextEditorSelectionRevealType.CenterIfOutsideViewport,
+                },
+            }, this.containingEditor || null, e.ctrlKey || e.metaKey);
+        }));
+        const cts = ( (new CancellationTokenSource()));
+        elementStore.add(toDisposable(() => cts.dispose(true)));
+        this.modelService.createModelReference(uri).then(reference => {
+            if (cts.token.isCancellationRequested) {
+                return reference.dispose();
+            }
+            elementStore.add(reference);
+            editor.setModel(reference.object.textEditorModel);
+            this.setupEditorAfterModel(item, template);
+            this.setupEditorLayout(item, template);
+        });
+    }
+    setupEditorLayout(item, { elementStore, container, editor }) {
+        const layout = () => {
+            const prev = editor.getContentHeight();
+            editor.layout({ width: container.clientWidth, height: prev });
+            const next = editor.getContentHeight();
+            if (next !== prev) {
+                editor.layout({ width: container.clientWidth, height: next });
+                item.editorHeight.set(next, undefined);
+            }
+        };
+        elementStore.add(this.onLayout(layout));
+        layout();
+    }
+    setupEditorAfterModel(item, template) {
+        const range = Range.fromPositions({
+            column: item.column ?? 1,
+            lineNumber: item.line ?? 1,
+        });
+        template.toolbar.context = { uri: item.source, range };
+        template.editor.setHiddenAreas([
+            Range.fromPositions({ column: 1, lineNumber: 1 }, { column: 1, lineNumber: Math.max(1, item.line - CONTEXT_LINES - 1) }),
+            Range.fromPositions({ column: 1, lineNumber: item.line + CONTEXT_LINES + 1 }, { column: 1, lineNumber: Constants.MAX_SAFE_SMALL_INTEGER }),
+        ]);
+        template.editor.changeDecorations(accessor => {
+            for (const d of template.decorations) {
+                accessor.removeDecoration(d);
+            }
+            template.decorations.length = 0;
+            const beforeRange = range.setStartPosition(range.startLineNumber, 1);
+            const hasCharactersBefore = !!template.editor.getModel()?.getValueInRange(beforeRange).trim();
+            const decoRange = range.setEndPosition(range.startLineNumber, Constants.MAX_SAFE_SMALL_INTEGER);
+            template.decorations.push(accessor.addDecoration(decoRange, makeStackFrameColumnDecoration(!hasCharactersBefore)));
+            template.decorations.push(accessor.addDecoration(decoRange, TOP_STACK_FRAME_DECORATION));
+        });
+        item.editorHeight.set(template.editor.getContentHeight(), undefined);
+    }
+};
+FrameCodeRenderer = FrameCodeRenderer_1 = ( (__decorate([
+    ( (__param(2, ITextModelService))),
+    ( (__param(3, ICodeEditorService))),
+    ( (__param(4, IInstantiationService)))
+], FrameCodeRenderer)));
+class MissingCodeRenderer {
+    constructor() {
+        this.templateId = MissingCodeRenderer.templateId;
+    }
+    static { this.templateId = 'm'; }
+    renderTemplate(container) {
+        return { container };
+    }
+    renderElement(element, index, templateData, height) {
+        templateData.container.innerText = element.name;
+    }
+    disposeTemplate(templateData) {
+        clearNode(templateData.container);
+    }
+}
+class CustomRenderer extends AbstractFrameRenderer {
+    constructor() {
+        super(...arguments);
+        this.templateId = CustomRenderer.templateId;
+    }
+    static { this.templateId = 'c'; }
+    finishRenderTemplate(data) {
+        return data;
+    }
+    renderElement(element, index, template, height) {
+        super.renderElement(element, index, template, height);
+        const item = element;
+        const { elementStore, container, label } = template;
+        label.element.setResource({ name: item.original.label }, { icon: item.original.icon });
+        elementStore.add(autorun(reader => {
+            template.elements.header.style.display = item.original.showHeader.read(reader) ? '' : 'none';
+        }));
+        elementStore.add(autorunWithStore((reader, store) => {
+            if (!item.collapsed.read(reader)) {
+                store.add(item.original.render(container));
+            }
+        }));
+        const actions = item.original.renderActions?.(template.elements.actions);
+        if (actions) {
+            elementStore.add(actions);
+        }
+    }
+}
+let SkippedRenderer = class SkippedRenderer {
+    static { SkippedRenderer_1 = this; }
+    static { this.templateId = 's'; }
+    constructor(loadFrames, notificationService) {
+        this.loadFrames = loadFrames;
+        this.notificationService = notificationService;
+        this.templateId = SkippedRenderer_1.templateId;
+    }
+    renderTemplate(container) {
+        const store = ( (new DisposableStore()));
+        const button = ( (new Button(container, { title: '', ...defaultButtonStyles })));
+        const data = { button, store };
+        store.add(button);
+        store.add(button.onDidClick(() => {
+            if (!data.current || !button.enabled) {
+                return;
+            }
+            button.enabled = false;
+            this.loadFrames(data.current).catch(e => {
+                this.notificationService.error(( localize(10728, 'Failed to load stack frames: {0}', e.message)));
+            });
+        }));
+        return data;
+    }
+    renderElement(element, index, templateData, height) {
+        const cast = element;
+        templateData.button.enabled = true;
+        templateData.button.label = cast.label;
+        templateData.current = cast;
+    }
+    disposeTemplate(templateData) {
+        templateData.store.dispose();
+    }
+};
+SkippedRenderer = SkippedRenderer_1 = ( (__decorate([
+    ( (__param(1, INotificationService)))
+], SkippedRenderer)));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'callStackWidget.goToFile',
+            title: ( localize2(10729, 'Open File')),
+            icon: Codicon.goToFile,
+            menu: {
+                id: MenuId.DebugCallStackToolbar,
+                order: 22,
+                group: 'navigation',
+            },
+        });
+    }
+    async run(accessor, { uri, range }) {
+        const editorService = accessor.get(IEditorService);
+        await editorService.openEditor({
+            resource: uri,
+            options: {
+                selection: range,
+                selectionRevealType: TextEditorSelectionRevealType.CenterIfOutsideViewport,
+            },
+        });
+    }
+});
+
+export { CallStackFrame, CallStackWidget, CustomStackFrame, SkippedCallFrames };

package/vscode/src/vs/workbench/contrib/debug/browser/media/callStackWidget.css.js

@@ -0,0 +1,6 @@
+import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".multiCallStackFrame{.header{align-items:center;background:var(--vscode-multiDiffEditor-headerBackground);border-top:1px solid var(--vscode-multiDiffEditor-border);color:var(--vscode-foreground);display:flex;height:32px;padding:0 5px}.title{flex-grow:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;&[role=link]{cursor:pointer}}&.collapsed{.header{border-bottom:1px solid var(--vscode-multiDiffEditor-border)}.editorParent{display:none}}.collapse-button{cursor:pointer}.actions{align-items:center;display:flex;gap:8px;margin-right:12px}}.multiCallStackWidget{.multiCallStackFrameContainer{background:none!important}}";
+n(css,{});
+
+export { css, css as default };

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

@@ -24,7 +24,7 @@ import { EditorOption } from 'vscode/vscode/vs/editor/common/config/editorOption
 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 { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
+import { localize, localize2 } from 'vscode/vscode/vs/nls';
 import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
 import { MenuId, registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
@@ -49,10 +49,9 @@ import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/
 import { DetailType } from 'vscode/vscode/vs/workbench/contrib/testing/common/testTypes';
 import { TestingContextKeys } from '../common/testingContextKeys.js';
 
-const _moduleId = "vs/workbench/contrib/testing/browser/codeCoverageDecorations";
 const CLASS_HIT = 'coverage-deco-hit';
 const CLASS_MISS = 'coverage-deco-miss';
-const TOGGLE_INLINE_COMMAND_TEXT = ( localizeWithPath(_moduleId, 0, 'Toggle Inline'));
+const TOGGLE_INLINE_COMMAND_TEXT = ( localize(8162, 'Toggle Inline'));
 const TOGGLE_INLINE_COMMAND_ID = 'testing.toggleInlineCoverage';
 const BRANCH_MISS_INDICATOR_CHARS = 4;
 let CodeCoverageDecorations = class CodeCoverageDecorations extends Disposable {
@@ -404,9 +403,8 @@ class CoverageDetailsModel {
             const text = wrapName(model.getValueInRange(tidyLocation(detail.location)).trim() || `<empty statement>`);
             if (detail.branches?.length) {
                 const covered = detail.branches.filter(b => !!b.count).length;
-                return ( (new MarkdownString())).appendMarkdown(( localizeWithPath(
-                    _moduleId,
-                    1,
+                return ( (new MarkdownString())).appendMarkdown(( localize(
+                    8163,
                     '{0} of {1} of branches in {2} were covered.',
                     covered,
                     detail.branches.length,
@@ -422,20 +420,13 @@ class CoverageDetailsModel {
             const { count, label } = detail.detail.branches[detail.branch];
             const label2 = label ? wrapInBackticks(label) : `#${detail.branch + 1}`;
             if (!count) {
-                return ( (new MarkdownString())).appendMarkdown(( localizeWithPath(_moduleId, 2, 'Branch {0} in {1} was not covered.', label2, text)));
+                return ( (new MarkdownString())).appendMarkdown(( localize(8164, 'Branch {0} in {1} was not covered.', label2, text)));
             }
             else if (count === true) {
-                return ( (new MarkdownString())).appendMarkdown(( localizeWithPath(_moduleId, 3, 'Branch {0} in {1} was executed.', label2, text)));
+                return ( (new MarkdownString())).appendMarkdown(( localize(8165, 'Branch {0} in {1} was executed.', label2, text)));
             }
             else {
-                return ( (new MarkdownString())).appendMarkdown(( localizeWithPath(
-                    _moduleId,
-                    4,
-                    'Branch {0} in {1} was executed {2} time(s).',
-                    label2,
-                    text,
-                    count
-                )));
+                return ( (new MarkdownString())).appendMarkdown(( localize(8166, 'Branch {0} in {1} was executed {2} time(s).', label2, text, count)));
             }
         }
         assertNever();
@@ -443,10 +434,10 @@ class CoverageDetailsModel {
 }
 function namedDetailLabel(name, detail) {
     return ( (new MarkdownString())).appendMarkdown(!detail.count
-        ? ( localizeWithPath(_moduleId, 5, '`{0}` was not executed.', name))
+        ? ( localize(8167, '`{0}` was not executed.', name))
         : typeof detail.count === 'number'
-            ? ( localizeWithPath(_moduleId, 6, '`{0}` was executed {1} time(s).', name, detail.count))
-            : ( localizeWithPath(_moduleId, 7, '`{0}` was executed.', name)));
+            ? ( localize(8168, '`{0}` was executed {1} time(s).', name, detail.count))
+            : ( localize(8169, '`{0}` was executed.', name)));
 }
 function tidyLocation(location) {
     if (location instanceof Position) {
@@ -543,8 +534,8 @@ let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
             return;
         }
         const toggleAction = ( (new ActionWithIcon('toggleInline', this.coverage.showInline.get()
-            ? ( localizeWithPath(_moduleId, 8, 'Hide Inline Coverage'))
-            : ( localizeWithPath(_moduleId, 9, 'Show Inline Coverage')), testingCoverageReport, undefined, () => this.coverage.showInline.set(!this.coverage.showInline.get(), undefined))));
+            ? ( localize(8170, 'Hide Inline Coverage'))
+            : ( localize(8171, 'Show Inline Coverage')), testingCoverageReport, undefined, () => this.coverage.showInline.set(!this.coverage.showInline.get(), undefined))));
         const kb = this.keybindingService.lookupKeybinding(TOGGLE_INLINE_COMMAND_ID);
         if (kb) {
             toggleAction.tooltip = `${TOGGLE_INLINE_COMMAND_TEXT} (${kb.getLabel()})`;
@@ -562,14 +553,13 @@ let CoverageToolbarWidget = class CoverageToolbarWidget extends Disposable {
             ))));
         }
         else if (current.coverage.perTestData?.size) {
-            this.actionBar.push(( (new ActionWithIcon('perTestFilter', ( localizeWithPath(
-                _moduleId,
-                10,
+            this.actionBar.push(( (new ActionWithIcon('perTestFilter', ( localize(
+                8172,
                 "{0} test(s) ran code in this file",
                 current.coverage.perTestData.size
             )), testingFilterIcon, undefined, () => this.commandService.executeCommand(TestCommandId.CoverageFilterToTestInEditor, this.current, this.editor)))));
         }
-        this.actionBar.push(( (new ActionWithIcon('rerun', ( localizeWithPath(_moduleId, 11, 'Rerun')), testingRerunIcon, !this.isRunning, () => this.rerunTest()))));
+        this.actionBar.push(( (new ActionWithIcon('rerun', ( localize(8173, 'Rerun')), testingRerunIcon, !this.isRunning, () => this.rerunTest()))));
     }
     show() {
         if (this.registered) {
@@ -629,7 +619,7 @@ registerAction2(class ToggleInlineCoverage extends Action2 {
     constructor() {
         super({
             id: TOGGLE_INLINE_COMMAND_ID,
-            title: ( localize2WithPath(_moduleId, 12, "Toggle Inline Coverage")),
+            title: ( localize2(8174, "Toggle Inline Coverage")),
             category: Categories.Test,
             keybinding: {
                 weight: KeybindingWeight.WorkbenchContrib,
@@ -637,7 +627,7 @@ registerAction2(class ToggleInlineCoverage extends Action2 {
             },
             toggled: {
                 condition: TestingContextKeys.inlineCoverageEnabled,
-                title: ( localizeWithPath(_moduleId, 13, "Hide Inline Coverage")),
+                title: ( localize(8175, "Hide Inline Coverage")),
             },
             icon: testingCoverageReport,
             menu: [
@@ -658,9 +648,9 @@ registerAction2(class ToggleCoverageToolbar extends Action2 {
     constructor() {
         super({
             id: TestCommandId.CoverageToggleToolbar,
-            title: ( localize2WithPath(_moduleId, 14, "Test Coverage Toolbar")),
+            title: ( localize2(8176, "Test Coverage Toolbar")),
             metadata: {
-                description: ( localize2WithPath(_moduleId, 15, 'Toggle the sticky coverage bar in the editor.'))
+                description: ( localize2(8177, 'Toggle the sticky coverage bar in the editor.'))
             },
             category: Categories.Test,
             toggled: {
@@ -683,7 +673,7 @@ registerAction2(class FilterCoverageToTestInEditor extends Action2 {
     constructor() {
         super({
             id: TestCommandId.CoverageFilterToTestInEditor,
-            title: ( localize2WithPath(_moduleId, 16, "Filter Coverage to Test")),
+            title: ( localize2(8178, "Filter Coverage to Test")),
             category: Categories.Test,
             icon: Codicon.filter,
             toggled: {