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

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 };