@codingame/monaco-vscode-debug-service-override 2.0.3 → 2.1.0

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

@@ -10,7 +10,8 @@ import { illegalArgument, onUnexpectedExternalError } from 'vscode/vscode/vs/bas
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { visit } from 'vscode/vscode/vs/base/common/json';
 import { setProperty } from 'vscode/vscode/vs/base/common/jsonEdit';
-import { dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { MutableDisposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { clamp } from 'vscode/vscode/vs/base/common/numbers';
 import { basename } from 'vscode/vscode/vs/base/common/path';
 import { isMacintosh } from 'vscode/vscode/vs/base/common/platform';
 import { format, noBreakWhitespace } from 'vscode/vscode/vs/base/common/strings';
@@ -25,7 +26,7 @@ import { InjectedTextCursorStops } from 'vscode/vscode/vs/editor/common/model';
 import { ILanguageFeatureDebounceService } from 'vscode/vscode/vs/editor/common/services/languageFeatureDebounce';
 import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
 import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { ModesHoverController } from 'vscode/vscode/vs/editor/contrib/hover/browser/hover';
+import { HoverController } from 'vscode/vscode/vs/editor/contrib/hover/browser/hover';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { CommandsRegistry, ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
@@ -113,7 +114,7 @@ function createInlineValueDecoration(lineNumber, contentText, column = 107374182
 function replaceWsWithNoBreakWs(str) {
     return str.replace(/[ \t]/g, noBreakWhitespace);
 }
-function createInlineValueDecorationsInsideRange(expressions, range, model, wordToLineNumbersMap) {
+function createInlineValueDecorationsInsideRange(expressions, ranges, model, wordToLineNumbersMap) {
     const nameValueMap = ( new Map());
     for (const expr of expressions) {
         nameValueMap.set(expr.name, expr.value);
@@ -126,7 +127,7 @@ function createInlineValueDecorationsInsideRange(expressions, range, model, word
         const lineNumbers = wordToLineNumbersMap.get(name);
         if (lineNumbers) {
             for (const lineNumber of lineNumbers) {
-                if (range.containsPosition(( new Position(lineNumber, 0)))) {
+                if (( ranges.some(r => lineNumber >= r.startLineNumber && lineNumber <= r.endLineNumber))) {
                     if (!( lineToNamesMap.has(lineNumber))) {
                         lineToNamesMap.set(lineNumber, []);
                     }
@@ -147,38 +148,31 @@ function createInlineValueDecorationsInsideRange(expressions, range, model, word
     });
     return decorations;
 }
-function getWordToLineNumbersMap(model) {
-    const result = ( new Map());
-    if (!model) {
-        return result;
-    }
-    for (let lineNumber = 1, len = model.getLineCount(); lineNumber <= len; ++lineNumber) {
-        const lineLength = model.getLineLength(lineNumber);
-        if (lineLength > MAX_TOKENIZATION_LINE_LEN) {
-            continue;
-        }
-        const lineContent = model.getLineContent(lineNumber);
-        model.tokenization.forceTokenization(lineNumber);
-        const lineTokens = model.tokenization.getLineTokens(lineNumber);
-        for (let tokenIndex = 0, tokenCount = lineTokens.getCount(); tokenIndex < tokenCount; tokenIndex++) {
-            const tokenType = lineTokens.getStandardTokenType(tokenIndex);
-            if (tokenType === 0 ) {
-                DEFAULT_WORD_REGEXP.lastIndex = 0;
-                const tokenStartOffset = lineTokens.getStartOffset(tokenIndex);
-                const tokenEndOffset = lineTokens.getEndOffset(tokenIndex);
-                const tokenStr = lineContent.substring(tokenStartOffset, tokenEndOffset);
-                const wordMatch = DEFAULT_WORD_REGEXP.exec(tokenStr);
-                if (wordMatch) {
-                    const word = wordMatch[0];
-                    if (!( result.has(word))) {
-                        result.set(word, []);
-                    }
-                    result.get(word).push(lineNumber);
+function getWordToLineNumbersMap(model, lineNumber, result) {
+    const lineLength = model.getLineLength(lineNumber);
+    if (lineLength > MAX_TOKENIZATION_LINE_LEN) {
+        return;
+    }
+    const lineContent = model.getLineContent(lineNumber);
+    model.tokenization.forceTokenization(lineNumber);
+    const lineTokens = model.tokenization.getLineTokens(lineNumber);
+    for (let tokenIndex = 0, tokenCount = lineTokens.getCount(); tokenIndex < tokenCount; tokenIndex++) {
+        const tokenType = lineTokens.getStandardTokenType(tokenIndex);
+        if (tokenType === 0 ) {
+            DEFAULT_WORD_REGEXP.lastIndex = 0;
+            const tokenStartOffset = lineTokens.getStartOffset(tokenIndex);
+            const tokenEndOffset = lineTokens.getEndOffset(tokenIndex);
+            const tokenStr = lineContent.substring(tokenStartOffset, tokenEndOffset);
+            const wordMatch = DEFAULT_WORD_REGEXP.exec(tokenStr);
+            if (wordMatch) {
+                const word = wordMatch[0];
+                if (!( result.has(word))) {
+                    result.set(word, []);
                 }
+                result.get(word).push(lineNumber);
             }
         }
     }
-    return result;
 }
 let DebugEditorContribution = class DebugEditorContribution {
     constructor(editor, debugService, instantiationService, commandService, configurationService, hostService, uriIdentityService, contextKeyService, languageFeaturesService, featureDebounceService) {
@@ -193,12 +187,13 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.hoverPosition = null;
         this.mouseDown = false;
         this.gutterIsHovered = false;
+        this.altListener = ( new MutableDisposable());
         this.altPressed = false;
         this.oldDecorations = this.editor.createDecorationsCollection();
-        this._wordToLineNumbersMap = undefined;
+        this.defaultHoverLockout = ( new MutableDisposable());
         this.debounceInfo = featureDebounceService.for(languageFeaturesService.inlineValuesProvider, 'InlineValues', { min: DEAFULT_INLINE_DEBOUNCE_DELAY });
         this.hoverWidget = this.instantiationService.createInstance(DebugHoverWidget, this.editor);
-        this.toDispose = [];
+        this.toDispose = [this.defaultHoverLockout, this.altListener];
         this.registerListeners();
         this.exceptionWidgetVisible = CONTEXT_EXCEPTION_WIDGET_VISIBLE.bindTo(contextKeyService);
         this.toggleExceptionWidget();
@@ -226,7 +221,7 @@ let DebugEditorContribution = class DebugEditorContribution {
         this.toDispose.push(this.debugService.getViewModel().onWillUpdateViews(() => this.updateInlineValuesScheduler.schedule()));
         this.toDispose.push(this.debugService.getViewModel().onDidEvaluateLazyExpression(() => this.updateInlineValuesScheduler.schedule()));
         this.toDispose.push(this.editor.onDidChangeModel(async () => {
-            this.updateHoverConfiguration();
+            this.addDocumentListeners();
             this.toggleExceptionWidget();
             this.hideHoverWidget();
             this._wordToLineNumbersMap = undefined;
@@ -240,81 +235,68 @@ let DebugEditorContribution = class DebugEditorContribution {
                 this.updateInlineValuesScheduler.schedule();
             }
         }));
+        this.toDispose.push(this.configurationService.onDidChangeConfiguration((e) => {
+            if (e.affectsConfiguration('editor.hover')) {
+                this.updateHoverConfiguration();
+            }
+        }));
         this.toDispose.push(this.debugService.onDidChangeState((state) => {
             if (state !== 2 ) {
                 this.toggleExceptionWidget();
             }
         }));
+        this.updateHoverConfiguration();
     }
-    get wordToLineNumbersMap() {
-        if (!this._wordToLineNumbersMap) {
-            this._wordToLineNumbersMap = getWordToLineNumbersMap(this.editor.getModel());
+    updateHoverConfiguration() {
+        const model = this.editor.getModel();
+        if (model) {
+            this.editorHoverOptions = this.configurationService.getValue('editor.hover', {
+                resource: model.uri,
+                overrideIdentifier: model.getLanguageId()
+            });
         }
-        return this._wordToLineNumbersMap;
     }
-    updateHoverConfiguration() {
+    addDocumentListeners() {
         const stackFrame = this.debugService.getViewModel().focusedStackFrame;
         const model = this.editor.getModel();
         if (model) {
-            this.applyHoverConfiguration(model, stackFrame);
+            this.applyDocumentListeners(model, stackFrame);
         }
     }
-    applyHoverConfiguration(model, stackFrame) {
-        if (stackFrame && this.uriIdentityService.extUri.isEqual(model.uri, stackFrame.source.uri)) {
-            const ownerDocument = this.editor.getContainerDomNode().ownerDocument;
-            if (this.altListener) {
-                this.altListener.dispose();
-            }
-            this.altListener = addDisposableListener(ownerDocument, 'keydown', keydownEvent => {
-                const standardKeyboardEvent = ( new StandardKeyboardEvent(keydownEvent));
-                if (standardKeyboardEvent.keyCode === 6 ) {
-                    this.altPressed = true;
-                    const debugHoverWasVisible = this.hoverWidget.isVisible();
-                    this.hoverWidget.hide();
-                    this.enableEditorHover();
-                    if (debugHoverWasVisible && this.hoverPosition) {
-                        this.showEditorHover(this.hoverPosition, false);
-                    }
-                    const onKeyUp = ( new DomEmitter(ownerDocument, 'keyup'));
-                    const listener = Event.any(this.hostService.onDidChangeFocus, onKeyUp.event)(keyupEvent => {
-                        let standardKeyboardEvent = undefined;
-                        if (isKeyboardEvent(keyupEvent)) {
-                            standardKeyboardEvent = ( new StandardKeyboardEvent(keyupEvent));
-                        }
-                        if (!standardKeyboardEvent || standardKeyboardEvent.keyCode === 6 ) {
-                            this.altPressed = false;
-                            this.editor.updateOptions({ hover: { enabled: false } });
-                            listener.dispose();
-                            onKeyUp.dispose();
-                        }
-                    });
-                }
-            });
-            this.editor.updateOptions({ hover: { enabled: false } });
-        }
-        else {
-            this.altListener?.dispose();
-            this.enableEditorHover();
+    applyDocumentListeners(model, stackFrame) {
+        if (!stackFrame || !this.uriIdentityService.extUri.isEqual(model.uri, stackFrame.source.uri)) {
+            this.altListener.clear();
+            return;
         }
-    }
-    enableEditorHover() {
-        if (this.editor.hasModel()) {
-            const model = this.editor.getModel();
-            const overrides = {
-                resource: model.uri,
-                overrideIdentifier: model.getLanguageId()
-            };
-            const defaultConfiguration = this.configurationService.getValue('editor.hover', overrides);
-            this.editor.updateOptions({
-                hover: {
-                    enabled: defaultConfiguration.enabled,
-                    delay: defaultConfiguration.delay,
-                    sticky: defaultConfiguration.sticky
+        const ownerDocument = this.editor.getContainerDomNode().ownerDocument;
+        this.altListener.value = addDisposableListener(ownerDocument, 'keydown', keydownEvent => {
+            const standardKeyboardEvent = ( new StandardKeyboardEvent(keydownEvent));
+            if (standardKeyboardEvent.keyCode === 6 ) {
+                this.altPressed = true;
+                const debugHoverWasVisible = this.hoverWidget.isVisible();
+                this.hoverWidget.hide();
+                this.defaultHoverLockout.clear();
+                if (debugHoverWasVisible && this.hoverPosition) {
+                    this.showEditorHover(this.hoverPosition, false);
                 }
-            });
-        }
+                const onKeyUp = ( new DomEmitter(ownerDocument, 'keyup'));
+                const listener = Event.any(this.hostService.onDidChangeFocus, onKeyUp.event)(keyupEvent => {
+                    let standardKeyboardEvent = undefined;
+                    if (isKeyboardEvent(keyupEvent)) {
+                        standardKeyboardEvent = ( new StandardKeyboardEvent(keyupEvent));
+                    }
+                    if (!standardKeyboardEvent || standardKeyboardEvent.keyCode === 6 ) {
+                        this.altPressed = false;
+                        this.preventDefaultEditorHover();
+                        listener.dispose();
+                        onKeyUp.dispose();
+                    }
+                });
+            }
+        });
     }
     async showHover(position, focus) {
+        this.preventDefaultEditorHover();
         const sf = this.debugService.getViewModel().focusedStackFrame;
         const model = this.editor.getModel();
         if (sf && model && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri)) {
@@ -327,15 +309,31 @@ let DebugEditorContribution = class DebugEditorContribution {
             this.showEditorHover(position, focus);
         }
     }
+    preventDefaultEditorHover() {
+        if (this.defaultHoverLockout.value || this.editorHoverOptions?.enabled === false) {
+            return;
+        }
+        const hoverController = this.editor.getContribution(HoverController.ID);
+        hoverController?.hideContentHover();
+        this.editor.updateOptions({ hover: { enabled: false } });
+        this.defaultHoverLockout.value = {
+            dispose: () => {
+                this.editor.updateOptions({
+                    hover: { enabled: this.editorHoverOptions?.enabled ?? true }
+                });
+            }
+        };
+    }
     showEditorHover(position, focus) {
-        const hoverController = this.editor.getContribution(ModesHoverController.ID);
+        const hoverController = this.editor.getContribution(HoverController.ID);
         const range = ( new Range(position.lineNumber, position.column, position.lineNumber, position.column));
+        this.defaultHoverLockout.clear();
         hoverController?.showContentHover(range, 1 , 0 , focus);
     }
     async onFocusStackFrame(sf) {
         const model = this.editor.getModel();
         if (model) {
-            this.applyHoverConfiguration(model, sf);
+            this.applyDocumentListeners(model, sf);
             if (sf && this.uriIdentityService.extUri.isEqual(sf.source.uri, model.uri)) {
                 await this.toggleExceptionWidget();
             }
@@ -345,30 +343,26 @@ let DebugEditorContribution = class DebugEditorContribution {
         }
         await this.updateInlineValueDecorations(sf);
     }
+    get hoverDelay() {
+        const baseDelay = this.editorHoverOptions?.delay || 0;
+        const delayFactor = clamp(2 - (baseDelay - 300) / 600, 1, 2);
+        return baseDelay * delayFactor;
+    }
     get showHoverScheduler() {
-        const hoverOption = this.editor.getOption(60 );
         const scheduler = ( new RunOnceScheduler(() => {
             if (this.hoverPosition && !this.altPressed) {
                 this.showHover(this.hoverPosition, false);
             }
-        }, hoverOption.delay * 2));
-        this.toDispose.push(scheduler);
-        return scheduler;
-    }
-    get hideHoverScheduler() {
-        const scheduler = ( new RunOnceScheduler(() => {
-            if (!this.hoverWidget.isHovered()) {
-                this.hoverWidget.hide();
-            }
-        }, 0));
+        }, this.hoverDelay));
         this.toDispose.push(scheduler);
         return scheduler;
     }
     hideHoverWidget() {
-        if (!this.hideHoverScheduler.isScheduled() && this.hoverWidget.willBeVisible()) {
-            this.hideHoverScheduler.schedule();
+        if (this.hoverWidget.willBeVisible()) {
+            this.hoverWidget.hide();
         }
         this.showHoverScheduler.cancel();
+        this.defaultHoverLockout.clear();
     }
     onEditorMouseDown(mouseEvent) {
         this.mouseDown = true;
@@ -385,7 +379,7 @@ let DebugEditorContribution = class DebugEditorContribution {
         const stopKey = isMacintosh ? 'metaKey' : 'ctrlKey';
         if (!this.altPressed) {
             if (target.type === 2 ) {
-                this.editor.updateOptions({ hover: { enabled: true } });
+                this.defaultHoverLockout.clear();
                 this.gutterIsHovered = true;
             }
             else if (this.gutterIsHovered) {
@@ -394,13 +388,16 @@ let DebugEditorContribution = class DebugEditorContribution {
             }
         }
         if (target.type === 9  && target.detail === DebugHoverWidget.ID && !mouseEvent.event[stopKey]) {
-            return;
+            const sticky = this.editorHoverOptions?.sticky ?? true;
+            if (sticky || this.hoverWidget.isShowingComplexValue) {
+                return;
+            }
         }
         if (target.type === 6 ) {
             if (target.position && !Position.equals(target.position, this.hoverPosition)) {
                 this.hoverPosition = target.position;
-                this.hideHoverScheduler.cancel();
-                this.showHoverScheduler.schedule();
+                this.preventDefaultEditorHover();
+                this.showHoverScheduler.schedule(this.hoverDelay);
             }
         }
         else if (!this.mouseDown) {
@@ -409,7 +406,7 @@ let DebugEditorContribution = class DebugEditorContribution {
     }
     onKeyDown(e) {
         const stopKey = isMacintosh ? 57  : 5 ;
-        if (e.keyCode !== stopKey) {
+        if (e.keyCode !== stopKey && e.keyCode !== 6 ) {
             this.hideHoverWidget();
         }
     }
@@ -545,6 +542,7 @@ let DebugEditorContribution = class DebugEditorContribution {
             return;
         }
         this.removeInlineValuesScheduler.cancel();
+        const viewRanges = this.editor.getVisibleRangesPlusViewportAboveBelow();
         let allDecorations;
         if (( this.languageFeaturesService.inlineValuesProvider.has(model))) {
             const findVariable = async (_key, caseSensitiveLookup) => {
@@ -569,11 +567,10 @@ let DebugEditorContribution = class DebugEditorContribution {
                 ))
             };
             const token = ( new CancellationTokenSource()).token;
-            const ranges = this.editor.getVisibleRangesPlusViewportAboveBelow();
             const providers = this.languageFeaturesService.inlineValuesProvider.ordered(model).reverse();
             allDecorations = [];
             const lineDecorations = ( new Map());
-            const promises = flatten(( providers.map(provider => ( ranges.map(
+            const promises = flatten(( providers.map(provider => ( viewRanges.map(
                 range => Promise.resolve(provider.provideInlineValues(model, range, ctx, token)).then(async (result) => {
                     if (result) {
                         for (const iv of result) {
@@ -642,11 +639,16 @@ let DebugEditorContribution = class DebugEditorContribution {
             const scopes = await stackFrame.getMostSpecificScopes(stackFrame.range);
             const decorationsPerScope = await Promise.all(( scopes.map(async (scope) => {
                 const variables = await scope.getChildren();
-                let range = ( new Range(0, 0, stackFrame.range.startLineNumber, stackFrame.range.startColumn));
+                let scopeRange = ( new Range(0, 0, stackFrame.range.startLineNumber, stackFrame.range.startColumn));
                 if (scope.range) {
-                    range = range.setStartPosition(scope.range.startLineNumber, scope.range.startColumn);
+                    scopeRange = scopeRange.setStartPosition(scope.range.startLineNumber, scope.range.startColumn);
+                }
+                const ownRanges = ( viewRanges.map(r => r.intersectRanges(scopeRange))).filter(isDefined);
+                this._wordToLineNumbersMap ??= ( new WordsToLineNumbersCache(model));
+                for (const range of ownRanges) {
+                    this._wordToLineNumbersMap.ensureRangePopulated(range);
                 }
-                return createInlineValueDecorationsInsideRange(variables, range, model, this.wordToLineNumbersMap);
+                return createInlineValueDecorationsInsideRange(variables, ownRanges, model, this._wordToLineNumbersMap.value);
             })));
             allDecorations = distinct(decorationsPerScope.reduce((previous, current) => previous.concat(current), []),
             decoration => `${decoration.range.startLineNumber}:${decoration?.options.after?.content}`);
@@ -667,9 +669,6 @@ let DebugEditorContribution = class DebugEditorContribution {
 DebugEditorContribution.__decorator = ( __decorate([
     memoize
 ], DebugEditorContribution.prototype, "showHoverScheduler", null));
-DebugEditorContribution.__decorator = ( __decorate([
-    memoize
-], DebugEditorContribution.prototype, "hideHoverScheduler", null));
 DebugEditorContribution.__decorator = ( __decorate([
     memoize
 ], DebugEditorContribution.prototype, "removeInlineValuesScheduler", null));
@@ -687,6 +686,23 @@ DebugEditorContribution = ( __decorate([
     ( __param(8, ILanguageFeaturesService)),
     ( __param(9, ILanguageFeatureDebounceService))
 ], DebugEditorContribution));
+class WordsToLineNumbersCache {
+    constructor(model) {
+        this.model = model;
+        this.value = ( new Map());
+        this.intervals = ( new Uint8Array(Math.ceil(model.getLineCount() / 8)));
+    }
+    ensureRangePopulated(range) {
+        for (let lineNumber = range.startLineNumber; lineNumber <= range.endLineNumber; lineNumber++) {
+            const bin = lineNumber >> 3;
+            const bit = 1 << (lineNumber & 0b111);
+            if (!(this.intervals[bin] & bit)) {
+                getWordToLineNumbersMap(this.model, lineNumber, this.value);
+                this.intervals[bin] |= bit;
+            }
+        }
+    }
+}
 CommandsRegistry.registerCommand('_executeInlineValueProvider', async (accessor, uri, iRange, context) => {
     assertType(URI.isUri(uri));
     assertType(Range.isIRange(iRange));

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

@@ -10,13 +10,16 @@ import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { ModelDecorationOptions } from 'vscode/vscode/vs/editor/common/model/textModel';
 import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { MenuId, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextMenuService } from 'vscode/vscode/vs/platform/contextview/browser/contextView';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { WorkbenchAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
 import { editorHoverBackground, asCssVariable, editorHoverBorder, editorHoverForeground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
-import { renderExpressionValue } from './baseDebugView.js';
+import { renderExpressionValue } from 'vscode/vscode/vs/workbench/contrib/debug/browser/baseDebugView';
 import { LinkDetector } from './linkDetector.js';
-import { VariablesRenderer } from './variablesView.js';
+import { VariablesRenderer, openContextMenuForVariableTreeElement } from './variablesView.js';
 import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { Variable, Expression } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugModel';
 import { getEvaluatableExpressionAtPosition } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
@@ -48,10 +51,16 @@ async function findExpressionInStackFrame(stackFrame, namesToFind) {
 let DebugHoverWidget = class DebugHoverWidget {
     static { DebugHoverWidget_1 = this; }
     static { this.ID = 'debug.hoverWidget'; }
-    constructor(editor, debugService, instantiationService) {
+    get isShowingComplexValue() {
+        return this.complexValueContainer?.hidden === false;
+    }
+    constructor(editor, debugService, instantiationService, menuService, contextKeyService, contextMenuService) {
         this.editor = editor;
         this.debugService = debugService;
         this.instantiationService = instantiationService;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.contextMenuService = contextMenuService;
         this.allowEditorOverflow = true;
         this.highlightDecorations = this.editor.createDecorationsCollection();
         this.isUpdatingTree = false;
@@ -96,6 +105,7 @@ let DebugHoverWidget = class DebugHoverWidget {
         this.domNode.style.backgroundColor = asCssVariable(editorHoverBackground);
         this.domNode.style.border = `1px solid ${asCssVariable(editorHoverBorder)}`;
         this.domNode.style.color = asCssVariable(editorHoverForeground);
+        this.toDispose.push(this.tree.onContextMenu(async (e) => await this.onContextMenu(e)));
         this.toDispose.push(this.tree.onDidChangeContentHeight(() => {
             if (!this.isUpdatingTree) {
                 this.layoutTreeAndContainer();
@@ -109,6 +119,13 @@ let DebugHoverWidget = class DebugHoverWidget {
         this.registerListeners();
         this.editor.addContentWidget(this);
     }
+    async onContextMenu(e) {
+        const variable = e.element;
+        if (!(variable instanceof Variable) || !variable.value) {
+            return;
+        }
+        return openContextMenuForVariableTreeElement(this.contextKeyService, this.menuService, this.contextMenuService, MenuId.DebugHoverContext, e);
+    }
     registerListeners() {
         this.toDispose.push(addStandardDisposableListener(this.domNode, 'keydown', (e) => {
             if (e.equals(9 )) {
@@ -222,7 +239,16 @@ let DebugHoverWidget = class DebugHoverWidget {
     }
     layoutTree() {
         const scrollBarHeight = 10;
-        const treeHeight = Math.min(Math.max(266, this.editor.getLayoutInfo().height * 0.55), this.tree.contentHeight + scrollBarHeight);
+        let maxHeightToAvoidCursorOverlay = Infinity;
+        if (this.showAtPosition) {
+            const editorTop = this.editor.getDomNode()?.offsetTop || 0;
+            const containerTop = this.treeContainer.offsetTop + editorTop;
+            const hoveredCharTop = this.editor.getTopForLineNumber(this.showAtPosition.lineNumber, true) - this.editor.getScrollTop();
+            if (containerTop < hoveredCharTop) {
+                maxHeightToAvoidCursorOverlay = hoveredCharTop + editorTop - 22;
+            }
+        }
+        const treeHeight = Math.min(Math.max(266, this.editor.getLayoutInfo().height * 0.55), this.tree.contentHeight + scrollBarHeight, maxHeightToAvoidCursorOverlay);
         const realTreeWidth = this.tree.contentWidth;
         const treeWidth = clamp(realTreeWidth, 400, 550);
         this.tree.layout(treeHeight, treeWidth);
@@ -273,7 +299,10 @@ let DebugHoverWidget = class DebugHoverWidget {
 };
 DebugHoverWidget = DebugHoverWidget_1 = ( __decorate([
     ( __param(1, IDebugService)),
-    ( __param(2, IInstantiationService))
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IMenuService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IContextMenuService))
 ], DebugHoverWidget));
 class DebugHoverAccessibilityProvider {
     getWidgetAriaLabel() {

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

@@ -18,7 +18,7 @@ class DebugMemoryFileSystemProvider {
         this.capabilities = 0
             | 1024
             | 4 ;
-        debugService.onDidEndSession(session => {
+        debugService.onDidEndSession(({ session }) => {
             for (const [fd, memory] of this.fdMemory) {
                 if (memory.session === session) {
                     this.close(fd);

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

@@ -3,7 +3,7 @@ import { Event } from 'vscode/vscode/vs/base/common/event';
 import { VIEWLET_ID, IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
 import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress';
 import { dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
 import { NotificationPriority } from 'vscode/vscode/vs/platform/notification/common/notification';
 
 let DebugProgressContribution = class DebugProgressContribution {