@codingame/monaco-vscode-debug-service-override 2.2.2 → 3.1.0

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

@@ -27,16 +27,16 @@ import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/te
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
 import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
 import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { AbstractExpressionsRenderer, renderVariable, renderViewTree } from 'vscode/vscode/vs/workbench/contrib/debug/browser/baseDebugView';
+import { AbstractExpressionsRenderer, renderExpressionValue, renderVariable, renderViewTree, AbstractExpressionDataSource } from 'vscode/vscode/vs/workbench/contrib/debug/browser/baseDebugView';
 import { LinkDetector } from './linkDetector.js';
 import { IDebugService, VARIABLES_VIEW_ID, CONTEXT_VARIABLES_FOCUSED, CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED, CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { getContextForVariable } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugContext';
-import { Variable, getUriForDebugMemory, Expression, ErrorScope, Scope, StackFrame } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { VisualizedExpression, Variable, getUriForDebugMemory, Expression, ErrorScope, Scope, StackFrame } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
 import { IDebugVisualizerService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugVisualizers';
 import { IEditorService, SIDE_GROUP } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 
-var VariablesRenderer_1;
+var VisualizedVariableRenderer_1, VariablesRenderer_1;
 const $ = $$1;
 let forgetScopes = true;
 let variableInternalContext;
@@ -75,8 +75,13 @@ let VariablesView = class VariablesView extends ViewPane {
         this.element.classList.add('debug-pane');
         container.classList.add('debug-variables');
         const treeContainer = renderViewTree(container);
-        const linkeDetector = this.instantiationService.createInstance(LinkDetector);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'VariablesView', treeContainer, ( new VariablesDelegate()), [this.instantiationService.createInstance(VariablesRenderer, linkeDetector), ( new ScopesRenderer()), ( new ScopeErrorRenderer())], ( new VariablesDataSource()), {
+        const linkDetector = this.instantiationService.createInstance(LinkDetector);
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'VariablesView', treeContainer, ( new VariablesDelegate()), [
+            this.instantiationService.createInstance(VariablesRenderer, linkDetector),
+            this.instantiationService.createInstance(VisualizedVariableRenderer, linkDetector),
+            ( new ScopesRenderer()),
+            ( new ScopeErrorRenderer()),
+        ], this.instantiationService.createInstance(VariablesDataSource), {
             accessibilityProvider: ( new VariablesAccessibilityProvider()),
             identityProvider: { getId: (element) => element.getId() },
             keyboardNavigationLabelProvider: { getKeyboardNavigationLabel: (e) => e.name },
@@ -84,6 +89,7 @@ let VariablesView = class VariablesView extends ViewPane {
                 listBackground: this.getBackgroundColor()
             }
         });
+        this._register(VisualizedVariableRenderer.rendererOnVisualizationRange(this.debugService.getViewModel(), this.tree));
         this.tree.setInput(this.debugService.getViewModel().focusedStackFrame ?? null);
         CONTEXT_VARIABLES_FOCUSED.bindTo(this.tree.contextKeyService);
         this._register(this.debugService.getViewModel().onDidFocusStackFrame(sf => {
@@ -113,7 +119,7 @@ let VariablesView = class VariablesView extends ViewPane {
         let horizontalScrolling;
         this._register(this.debugService.getViewModel().onDidSelectExpression(e => {
             const variable = e?.expression;
-            if (variable instanceof Variable && !e?.settingWatch) {
+            if (variable && this.tree.hasNode(variable)) {
                 horizontalScrolling = this.tree.options.horizontalScrolling;
                 if (horizontalScrolling) {
                     this.tree.updateOptions({ horizontalScrolling: false });
@@ -148,11 +154,20 @@ let VariablesView = class VariablesView extends ViewPane {
         this.tree.collapseAll();
     }
     onMouseDblClick(e) {
-        const session = this.debugService.getViewModel().focusedSession;
-        if (session && e.element instanceof Variable && session.capabilities.supportsSetVariable && !e.element.presentationHint?.attributes?.includes('readOnly') && !e.element.presentationHint?.lazy) {
+        if (this.canSetExpressionValue(e.element)) {
             this.debugService.getViewModel().setSelectedExpression(e.element, false);
         }
     }
+    canSetExpressionValue(e) {
+        const session = this.debugService.getViewModel().focusedSession;
+        if (!session) {
+            return false;
+        }
+        if (e instanceof VisualizedExpression) {
+            return !!e.treeItem.canEdit;
+        }
+        return e instanceof Variable && !e.presentationHint?.attributes?.includes('readOnly') && !e.presentationHint?.lazy;
+    }
     async onContextMenu(e) {
         const variable = e.element;
         if (!(variable instanceof Variable) || !variable.value) {
@@ -238,7 +253,7 @@ function getContextForVariableMenuBase(parentContext, variable, additionalContex
 function isStackFrame(obj) {
     return obj instanceof StackFrame;
 }
-class VariablesDataSource {
+class VariablesDataSource extends AbstractExpressionDataSource {
     hasChildren(element) {
         if (!element) {
             return false;
@@ -248,7 +263,7 @@ class VariablesDataSource {
         }
         return element.hasChildren;
     }
-    getChildren(element) {
+    doGetChildren(element) {
         if (isStackFrame(element)) {
             return element.getScopes();
         }
@@ -266,6 +281,9 @@ class VariablesDelegate {
         if (element instanceof Scope) {
             return ScopesRenderer.ID;
         }
+        if (element instanceof VisualizedExpression) {
+            return VisualizedVariableRenderer.ID;
+        }
         return VariablesRenderer.ID;
     }
 }
@@ -301,6 +319,96 @@ class ScopeErrorRenderer {
     disposeTemplate() {
     }
 }
+let VisualizedVariableRenderer = class VisualizedVariableRenderer extends AbstractExpressionsRenderer {
+    static { VisualizedVariableRenderer_1 = this; }
+    static { this.ID = 'viz'; }
+    static rendererOnVisualizationRange(model, tree) {
+        return model.onDidChangeVisualization(({ original }) => {
+            if (!tree.hasNode(original)) {
+                return;
+            }
+            const parent = tree.getParentElement(original);
+            tree.updateChildren(parent, false, false);
+        });
+    }
+    constructor(linkDetector, debugService, contextViewService, menuService, contextKeyService) {
+        super(debugService, contextViewService);
+        this.linkDetector = linkDetector;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+    }
+    get templateId() {
+        return VisualizedVariableRenderer_1.ID;
+    }
+    renderElement(node, index, data) {
+        super.renderExpressionElement(node.element, node, data);
+    }
+    renderExpression(expression, data, highlights) {
+        const viz = expression;
+        let text = viz.name;
+        if (viz.value && typeof viz.name === 'string') {
+            text += ':';
+        }
+        data.label.set(text, highlights, viz.name);
+        renderExpressionValue(viz, data.value, {
+            showChanged: false,
+            maxValueLength: 1024,
+            showHover: true,
+            colorize: true,
+            linkDetector: this.linkDetector
+        });
+    }
+    getInputBoxOptions(expression) {
+        const viz = expression;
+        return {
+            initialValue: expression.value,
+            ariaLabel: ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/variablesView',
+                'variableValueAriaLabel',
+                "Type new variable value"
+            )),
+            validationOptions: {
+                validation: () => viz.errorMessage ? ({ content: viz.errorMessage }) : null
+            },
+            onFinish: (value, success) => {
+                viz.errorMessage = undefined;
+                if (success) {
+                    viz.edit(value).then(() => {
+                        forgetScopes = false;
+                        this.debugService.getViewModel().updateViews();
+                    });
+                }
+            }
+        };
+    }
+    renderActionBar(actionBar, expression, _data) {
+        const viz = expression;
+        const contextKeyService = viz.original ? getContextForVariableMenuBase(this.contextKeyService, viz.original) : this.contextKeyService;
+        const menu = this.menuService.createMenu(MenuId.DebugVariablesContext, contextKeyService);
+        const primary = [];
+        const context = viz.original ? getVariablesContext(viz.original) : undefined;
+        createAndFillInContextMenuActions(menu, { arg: context, shouldForwardArgs: false }, { primary, secondary: [] }, 'inline');
+        if (viz.original) {
+            const action = ( new Action('debugViz', ( localizeWithPath(
+                'vs/workbench/contrib/debug/browser/variablesView',
+                'removeVisualizer',
+                'Remove Visualizer'
+            )), ThemeIcon.asClassName(Codicon.eye), true, () => this.debugService.getViewModel().setVisualizedExpression(viz.original, undefined)));
+            action.checked = true;
+            primary.push(action);
+            actionBar.domNode.style.display = 'initial';
+        }
+        actionBar.clear();
+        actionBar.context = context;
+        actionBar.push(primary, { icon: true, label: false });
+    }
+};
+VisualizedVariableRenderer = VisualizedVariableRenderer_1 = ( __decorate([
+    ( __param(1, IDebugService)),
+    ( __param(2, IContextViewService)),
+    ( __param(3, IMenuService)),
+    ( __param(4, IContextKeyService))
+], VisualizedVariableRenderer));
 let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRenderer {
     static { VariablesRenderer_1 = this; }
     static { this.ID = 'variable'; }
@@ -360,12 +468,13 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
         data.elementDisposable.add(toDisposable(() => cts.dispose(true)));
         this.visualization.getApplicableFor(expression, cts.token).then(result => {
             data.elementDisposable.add(result);
+            const originalExpression = (expression instanceof VisualizedExpression && expression.original) || expression;
             const actions = ( result.object.map(v => ( new Action(
                 'debugViz',
                 v.name,
                 v.iconClass || 'debug-viz-icon',
                 undefined,
-                this.useVisualizer(v, cts.token)
+                this.useVisualizer(v, originalExpression, cts.token)
             ))));
             if (actions.length === 0) ;
             else if (actions.length === 1) {
@@ -376,7 +485,7 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
                     'vs/workbench/contrib/debug/browser/variablesView',
                     'useVisualizer',
                     'Visualize Variable...'
-                )), ThemeIcon.asClassName(Codicon.eye), undefined, () => this.pickVisualizer(actions, expression, data))), { icon: true, label: false });
+                )), ThemeIcon.asClassName(Codicon.eye), undefined, () => this.pickVisualizer(actions, originalExpression, data))), { icon: true, label: false });
             }
         });
     }
@@ -386,7 +495,7 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
             getActions: () => actions,
         });
     }
-    useVisualizer(viz, token) {
+    useVisualizer(viz, expression, token) {
         return async () => {
             const resolved = await viz.resolve(token);
             if (token.isCancellationRequested) {
@@ -396,7 +505,10 @@ let VariablesRenderer = class VariablesRenderer extends AbstractExpressionsRende
                 viz.execute();
             }
             else {
-                throw new Error('not implemented, yet');
+                const replacement = await this.visualization.getVisualizedNodeFor(resolved.id, expression);
+                if (replacement) {
+                    this.debugService.getViewModel().setVisualizedExpression(expression, replacement);
+                }
             }
         };
     }
@@ -584,7 +696,7 @@ CommandsRegistry.registerCommand({
     handler: async (accessor) => {
         const debugService = accessor.get(IDebugService);
         if (dataBreakpointInfoResponse) {
-            await debugService.addDataBreakpoint(dataBreakpointInfoResponse.description, dataBreakpointInfoResponse.dataId, !!dataBreakpointInfoResponse.canPersist, dataBreakpointInfoResponse.accessTypes, 'write');
+            await debugService.addDataBreakpoint(dataBreakpointInfoResponse.description, dataBreakpointInfoResponse.dataId, !!dataBreakpointInfoResponse.canPersist, dataBreakpointInfoResponse.accessTypes, 'write', undefined);
         }
     }
 });
@@ -594,7 +706,7 @@ CommandsRegistry.registerCommand({
     handler: async (accessor) => {
         const debugService = accessor.get(IDebugService);
         if (dataBreakpointInfoResponse) {
-            await debugService.addDataBreakpoint(dataBreakpointInfoResponse.description, dataBreakpointInfoResponse.dataId, !!dataBreakpointInfoResponse.canPersist, dataBreakpointInfoResponse.accessTypes, 'readWrite');
+            await debugService.addDataBreakpoint(dataBreakpointInfoResponse.description, dataBreakpointInfoResponse.dataId, !!dataBreakpointInfoResponse.canPersist, dataBreakpointInfoResponse.accessTypes, 'readWrite', undefined);
         }
     }
 });
@@ -604,7 +716,7 @@ CommandsRegistry.registerCommand({
     handler: async (accessor) => {
         const debugService = accessor.get(IDebugService);
         if (dataBreakpointInfoResponse) {
-            await debugService.addDataBreakpoint(dataBreakpointInfoResponse.description, dataBreakpointInfoResponse.dataId, !!dataBreakpointInfoResponse.canPersist, dataBreakpointInfoResponse.accessTypes, 'read');
+            await debugService.addDataBreakpoint(dataBreakpointInfoResponse.description, dataBreakpointInfoResponse.dataId, !!dataBreakpointInfoResponse.canPersist, dataBreakpointInfoResponse.accessTypes, 'read', undefined);
         }
     }
 });
@@ -648,4 +760,4 @@ registerAction2(class extends ViewAction {
     }
 });
 
-export { ADD_TO_WATCH_ID, BREAK_WHEN_VALUE_CHANGES_ID, BREAK_WHEN_VALUE_IS_ACCESSED_ID, BREAK_WHEN_VALUE_IS_READ_ID, COPY_EVALUATE_PATH_ID, COPY_VALUE_ID, SET_VARIABLE_ID, VIEW_MEMORY_ID, VariablesRenderer, VariablesView, openContextMenuForVariableTreeElement };
+export { ADD_TO_WATCH_ID, BREAK_WHEN_VALUE_CHANGES_ID, BREAK_WHEN_VALUE_IS_ACCESSED_ID, BREAK_WHEN_VALUE_IS_READ_ID, COPY_EVALUATE_PATH_ID, COPY_VALUE_ID, SET_VARIABLE_ID, VIEW_MEMORY_ID, VariablesRenderer, VariablesView, VisualizedVariableRenderer, openContextMenuForVariableTreeElement };

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

@@ -1,27 +1,27 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ElementsDragAndDropData } from 'vscode/vscode/vs/base/browser/ui/list/listView';
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { CONTEXT_CAN_VIEW_MEMORY, CONTEXT_WATCH_ITEM_TYPE, WATCH_VIEW_ID, CONTEXT_WATCH_EXPRESSIONS_EXIST, IDebugService, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_WATCH_EXPRESSIONS_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
-import { Variable, Expression } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { createAndFillInContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
+import { MenuId, registerAction2, Action2, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextMenuService, IContextViewService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { AbstractExpressionsRenderer, renderExpressionValue, renderViewTree } from 'vscode/vscode/vs/workbench/contrib/debug/browser/baseDebugView';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
 import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
-import { ElementsDragAndDropData } from 'vscode/vscode/vs/base/browser/ui/list/listView';
-import { VariablesRenderer } from './variablesView.js';
-import { ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
 import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { ViewAction, ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { AbstractExpressionsRenderer, renderExpressionValue, renderViewTree, AbstractExpressionDataSource } from 'vscode/vscode/vs/workbench/contrib/debug/browser/baseDebugView';
 import { watchExpressionsAdd, watchExpressionsRemoveAll } from 'vscode/vscode/vs/workbench/contrib/debug/browser/debugIcons';
-import { MenuId, registerAction2, Action2, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { createAndFillInContextMenuActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
 import { LinkDetector } from './linkDetector.js';
+import { VariablesRenderer, VisualizedVariableRenderer } from './variablesView.js';
+import { CONTEXT_CAN_VIEW_MEMORY, CONTEXT_WATCH_ITEM_TYPE, WATCH_VIEW_ID, CONTEXT_WATCH_EXPRESSIONS_EXIST, IDebugService, CONTEXT_VARIABLE_IS_READONLY, CONTEXT_WATCH_EXPRESSIONS_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { Variable, Expression, VisualizedExpression } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
 
 var WatchExpressionsRenderer_1;
 const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
@@ -49,8 +49,12 @@ let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
         container.classList.add('debug-watch');
         const treeContainer = renderViewTree(container);
         const expressionsRenderer = this.instantiationService.createInstance(WatchExpressionsRenderer);
-        const linkeDetector = this.instantiationService.createInstance(LinkDetector);
-        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'WatchExpressions', treeContainer, ( new WatchExpressionsDelegate()), [expressionsRenderer, this.instantiationService.createInstance(VariablesRenderer, linkeDetector)], ( new WatchExpressionsDataSource()), {
+        const linkDetector = this.instantiationService.createInstance(LinkDetector);
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'WatchExpressions', treeContainer, ( new WatchExpressionsDelegate()), [
+            expressionsRenderer,
+            this.instantiationService.createInstance(VariablesRenderer, linkDetector),
+            this.instantiationService.createInstance(VisualizedVariableRenderer, linkDetector),
+        ], this.instantiationService.createInstance(WatchExpressionsDataSource), {
             accessibilityProvider: ( new WatchExpressionsAccessibilityProvider()),
             identityProvider: { getId: (element) => element.getId() },
             keyboardNavigationLabelProvider: {
@@ -68,6 +72,7 @@ let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
         });
         this.tree.setInput(this.debugService);
         CONTEXT_WATCH_EXPRESSIONS_FOCUSED.bindTo(this.tree.contextKeyService);
+        this._register(VisualizedVariableRenderer.rendererOnVisualizationRange(this.debugService.getViewModel(), this.tree));
         this._register(this.tree.onContextMenu(e => this.onContextMenu(e)));
         this._register(this.tree.onMouseDblClick(e => this.onMouseDblClick(e)));
         this._register(this.debugService.getModel().onDidChangeWatchExpressions(async (we) => {
@@ -108,7 +113,7 @@ let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
         let horizontalScrolling;
         this._register(this.debugService.getViewModel().onDidSelectExpression(e => {
             const expression = e?.expression;
-            if (expression instanceof Expression || (expression instanceof Variable && e?.settingWatch)) {
+            if (expression && this.tree.hasElement(expression)) {
                 horizontalScrolling = this.tree.options.horizontalScrolling;
                 if (horizontalScrolling) {
                     this.tree.updateOptions({ horizontalScrolling: false });
@@ -146,7 +151,7 @@ let WatchExpressionsView = class WatchExpressionsView extends ViewPane {
         }
         const element = e.element;
         const selectedExpression = this.debugService.getViewModel().getSelectedExpression();
-        if (element instanceof Expression && element !== selectedExpression?.expression) {
+        if ((element instanceof Expression && element !== selectedExpression?.expression) || (element instanceof VisualizedExpression && element.treeItem.canEdit)) {
             this.debugService.getViewModel().setSelectedExpression(element, false);
         }
         else if (!element) {
@@ -189,17 +194,20 @@ class WatchExpressionsDelegate {
         if (element instanceof Expression) {
             return WatchExpressionsRenderer.ID;
         }
+        if (element instanceof VisualizedExpression) {
+            return VisualizedVariableRenderer.ID;
+        }
         return VariablesRenderer.ID;
     }
 }
 function isDebugService(element) {
     return typeof element.getConfigurationManager === 'function';
 }
-class WatchExpressionsDataSource {
+class WatchExpressionsDataSource extends AbstractExpressionDataSource {
     hasChildren(element) {
         return isDebugService(element) || element.hasChildren;
     }
-    getChildren(element) {
+    doGetChildren(element) {
         if (isDebugService(element)) {
             const debugService = element;
             const watchExpressions = debugService.getModel().getWatchExpressions();

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

@@ -141,8 +141,9 @@ viewsRegistry.registerViewWelcomeContent(WelcomeView.ID, {
     content: ( localizeWithPath('vs/workbench/contrib/debug/browser/welcomeView', {
         key: 'customizeRunAndDebugOpenFolder',
         comment: [
-            'Please do not translate the word "commmand", it is part of our internal syntax which must not change',
-            '{Locked="](command:{0})"}'
+            'Please do not translate the word "command", it is part of our internal syntax which must not change',
+            'Please do not translate "launch.json", it is the specific configuration file name',
+            '{Locked="](command:{0})"}',
         ]
     }, "To customize Run and Debug, [open a folder](command:{0}) and create a launch.json file.", (isMacintosh && !isWeb) ? OpenFileFolderAction.ID : OpenFolderAction.ID)),
     when: ( ContextKeyExpr.and(CONTEXT_DEBUGGERS_AVAILABLE, ( WorkbenchStateContext.isEqualTo('empty')))),

package/vscode/src/vs/workbench/contrib/debug/common/debugSchemas.js

@@ -2,8 +2,12 @@ import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensio
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { launchSchemaId } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
 import { inputsSchema } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolverSchema';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 
-const debuggersExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+const debuggersExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'debuggers',
     defaultExtensionKind: ['workspace'],
     jsonSchema: {
@@ -209,8 +213,8 @@ const debuggersExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
             }
         }
     }
-}));
-const breakpointsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+});
+const breakpointsExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'breakpoints',
     jsonSchema: {
         description: ( localizeWithPath(
@@ -245,7 +249,7 @@ const breakpointsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
             }
         }
     }
-}));
+});
 const presentationSchema = {
     type: 'object',
     description: ( localizeWithPath(
@@ -412,5 +416,45 @@ const launchSchema = {
         inputs: inputsSchema.definitions.inputs
     }
 };
+class DebuggersDataRenderer extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.type = 'table';
+    }
+    shouldRender(manifest) {
+        return !!manifest.contributes?.debuggers;
+    }
+    render(manifest) {
+        const contrib = manifest.contributes?.debuggers || [];
+        if (!contrib.length) {
+            return { data: { headers: [], rows: [] }, dispose: () => { } };
+        }
+        const headers = [
+            ( localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'debugger name', "Name")),
+            ( localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'debugger type', "Type")),
+        ];
+        const rows = ( contrib.map(d => {
+            return [
+                d.label ?? '',
+                d.type
+            ];
+        }));
+        return {
+            data: {
+                headers,
+                rows
+            },
+            dispose: () => { }
+        };
+    }
+}
+( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
+    id: 'debuggers',
+    label: ( localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'debuggers', "Debuggers")),
+    access: {
+        canToggle: false
+    },
+    renderer: ( new SyncDescriptor(DebuggersDataRenderer)),
+});
 
 export { breakpointsExtPoint, debuggersExtPoint, launchSchema, presentationSchema };

package/vscode/src/vs/workbench/contrib/debug/common/debugStorage.js

@@ -54,7 +54,14 @@ let DebugStorage = class DebugStorage extends Disposable {
         let result;
         try {
             result = ( JSON.parse(this.storageService.get(DEBUG_BREAKPOINTS_KEY, 1 , '[]')).map((breakpoint) => {
-                return ( new Breakpoint(( URI.parse(breakpoint.uri.external || breakpoint.source.uri.external)), breakpoint.lineNumber, breakpoint.column, breakpoint.enabled, breakpoint.condition, breakpoint.hitCondition, breakpoint.logMessage, breakpoint.adapterData, this.textFileService, this.uriIdentityService, this.logService, breakpoint.id, breakpoint.triggeredBy));
+                breakpoint.uri = URI.revive(breakpoint.uri);
+                return ( new Breakpoint(
+                    breakpoint,
+                    this.textFileService,
+                    this.uriIdentityService,
+                    this.logService,
+                    breakpoint.id
+                ));
             }));
         }
         catch (e) { }
@@ -64,7 +71,7 @@ let DebugStorage = class DebugStorage extends Disposable {
         let result;
         try {
             result = ( JSON.parse(this.storageService.get(DEBUG_FUNCTION_BREAKPOINTS_KEY, 1 , '[]')).map((fb) => {
-                return ( new FunctionBreakpoint(fb.name, fb.enabled, fb.hitCondition, fb.condition, fb.logMessage, fb.id));
+                return ( new FunctionBreakpoint(fb, fb.id));
             }));
         }
         catch (e) { }
@@ -74,16 +81,7 @@ let DebugStorage = class DebugStorage extends Disposable {
         let result;
         try {
             result = ( JSON.parse(this.storageService.get(DEBUG_EXCEPTION_BREAKPOINTS_KEY, 1 , '[]')).map((exBreakpoint) => {
-                return ( new ExceptionBreakpoint(
-                    exBreakpoint.filter,
-                    exBreakpoint.label,
-                    exBreakpoint.enabled,
-                    exBreakpoint.supportsCondition,
-                    exBreakpoint.condition,
-                    exBreakpoint.description,
-                    exBreakpoint.conditionDescription,
-                    !!exBreakpoint.fallback
-                ));
+                return ( new ExceptionBreakpoint(exBreakpoint, exBreakpoint.id));
             }));
         }
         catch (e) { }
@@ -93,18 +91,7 @@ let DebugStorage = class DebugStorage extends Disposable {
         let result;
         try {
             result = ( JSON.parse(this.storageService.get(DEBUG_DATA_BREAKPOINTS_KEY, 1 , '[]')).map((dbp) => {
-                return ( new DataBreakpoint(
-                    dbp.description,
-                    dbp.dataId,
-                    true,
-                    dbp.enabled,
-                    dbp.hitCondition,
-                    dbp.condition,
-                    dbp.logMessage,
-                    dbp.accessTypes,
-                    dbp.accessType,
-                    dbp.id
-                ));
+                return ( new DataBreakpoint(dbp, dbp.id));
             }));
         }
         catch (e) { }

package/vscode/src/vs/workbench/contrib/debug/common/debugViewModel.js

@@ -12,6 +12,9 @@ class ViewModel {
         this._onDidSelectExpression = ( new Emitter());
         this._onDidEvaluateLazyExpression = ( new Emitter());
         this._onWillUpdateViews = ( new Emitter());
+        this._onDidChangeVisualization = ( new Emitter());
+        this.visualized = ( new WeakMap());
+        this.preferredVisualizers = ( new Map());
         contextKeyService.bufferChangeEvents(() => {
             this.expressionSelectedContextKey = CONTEXT_EXPRESSION_SELECTED.bindTo(contextKeyService);
             this.loadedScriptsSupportedContextKey = CONTEXT_LOADED_SCRIPTS_SUPPORTED.bindTo(contextKeyService);
@@ -84,6 +87,9 @@ class ViewModel {
     get onDidFocusStackFrame() {
         return this._onDidFocusStackFrame.event;
     }
+    get onDidChangeVisualization() {
+        return this._onDidChangeVisualization.event;
+    }
     getSelectedExpression() {
         return this.selectedExpression;
     }
@@ -110,10 +116,33 @@ class ViewModel {
     setMultiSessionView(isMultiSessionView) {
         this.multiSessionDebug.set(isMultiSessionView);
     }
+    setVisualizedExpression(original, visualized) {
+        const current = this.visualized.get(original) || original;
+        const key = this.getPreferredVisualizedKey(original);
+        if (visualized) {
+            this.visualized.set(original, visualized);
+            this.preferredVisualizers.set(key, visualized.treeId);
+        }
+        else {
+            this.visualized.delete(original);
+            this.preferredVisualizers.delete(key);
+        }
+        this._onDidChangeVisualization.fire({ original: current, replacement: visualized || original });
+    }
+    getVisualizedExpression(expression) {
+        return this.visualized.get(expression) || this.preferredVisualizers.get(this.getPreferredVisualizedKey(expression));
+    }
     async evaluateLazyExpression(expression) {
         await expression.evaluateLazy();
         this._onDidEvaluateLazyExpression.fire(expression);
     }
+    getPreferredVisualizedKey(expr) {
+        return JSON.stringify([
+            expr.name,
+            expr.type,
+            !!expr.memoryReference,
+        ].join('\0'));
+    }
 }
 
 export { ViewModel };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands.js

@@ -0,0 +1,64 @@
+import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+
+const COPY_NOTEBOOK_VARIABLE_VALUE_ID = 'workbench.debug.viewlet.action.copyWorkspaceVariableValue';
+const COPY_NOTEBOOK_VARIABLE_VALUE_LABEL = ( localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands',
+    'copyWorkspaceVariableValue',
+    "Copy Value"
+));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: COPY_NOTEBOOK_VARIABLE_VALUE_ID,
+            title: COPY_NOTEBOOK_VARIABLE_VALUE_LABEL,
+            f1: false,
+        });
+    }
+    run(accessor, context) {
+        const clipboardService = accessor.get(IClipboardService);
+        if (context.value) {
+            clipboardService.writeText(context.value);
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: '_executeNotebookVariableProvider',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/notebookVariables/notebookVariableCommands',
+                'executeNotebookVariableProvider',
+                "Execute Notebook Variable Provider"
+            )),
+            f1: false,
+        });
+    }
+    async run(accessor, resource) {
+        if (!resource) {
+            return [];
+        }
+        const uri = URI.revive(resource);
+        const notebookKernelService = accessor.get(INotebookKernelService);
+        const notebookService = accessor.get(INotebookService);
+        const notebookTextModel = notebookService.getNotebookTextModel(uri);
+        if (!notebookTextModel) {
+            return [];
+        }
+        const selectedKernel = notebookKernelService.getMatchingKernel(notebookTextModel).selected;
+        if (selectedKernel && selectedKernel.hasVariableProvider) {
+            const variables = selectedKernel.provideVariables(notebookTextModel.uri, undefined, 'named', 0, CancellationToken.None);
+            return await ( variables
+                .map(variable => { return variable; }))
+                .toPromise();
+        }
+        return [];
+    }
+});
+
+export { COPY_NOTEBOOK_VARIABLE_VALUE_ID, COPY_NOTEBOOK_VARIABLE_VALUE_LABEL };