VSCode merge (#4610)

* Merge from vscode e388c734f30757875976c7e326d6cfeee77710de

* fix yarn lcoks

* remove small issue

src/vs/workbench/contrib/debug/browser/callStackView.ts

@@ -15,10 +15,8 @@ import { MenuId, IMenu, IMenuService } from 'vs/platform/actions/common/actions'
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { renderViewTree } from 'vs/workbench/contrib/debug/browser/baseDebugView';
 import { IAction } from 'vs/base/common/actions';
-import { RestartAction, StopAction, ContinueAction, StepOverAction, StepIntoAction, StepOutAction, PauseAction, RestartFrameAction, TerminateThreadAction, CopyStackTraceAction } from 'vs/workbench/contrib/debug/browser/debugActions';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { Separator } from 'vs/base/browser/ui/actionbar/actionbar';
 import { IContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { IViewletPanelOptions, ViewletPanel } from 'vs/workbench/browser/parts/views/panelViewlet';
 import { ILabelService } from 'vs/platform/label/common/label';
@@ -264,32 +262,13 @@ export class CallStackView extends ViewletPanel {
 	}
 
 	private onContextMenu(e: ITreeContextMenuEvent<CallStackItem>): void {
-		const actions: IAction[] = [];
 		const element = e.element;
 		if (isDebugSession(element)) {
 			this.callStackItemType.set('session');
-			actions.push(this.instantiationService.createInstance(RestartAction, RestartAction.ID, RestartAction.LABEL));
-			actions.push(new StopAction(StopAction.ID, StopAction.LABEL, this.debugService, this.keybindingService));
 		} else if (element instanceof Thread) {
 			this.callStackItemType.set('thread');
-			const thread = <Thread>element;
-			if (thread.stopped) {
-				actions.push(new ContinueAction(ContinueAction.ID, ContinueAction.LABEL, this.debugService, this.keybindingService));
-				actions.push(new StepOverAction(StepOverAction.ID, StepOverAction.LABEL, this.debugService, this.keybindingService));
-				actions.push(new StepIntoAction(StepIntoAction.ID, StepIntoAction.LABEL, this.debugService, this.keybindingService));
-				actions.push(new StepOutAction(StepOutAction.ID, StepOutAction.LABEL, this.debugService, this.keybindingService));
-			} else {
-				actions.push(new PauseAction(PauseAction.ID, PauseAction.LABEL, this.debugService, this.keybindingService));
-			}
-
-			actions.push(new Separator());
-			actions.push(new TerminateThreadAction(TerminateThreadAction.ID, TerminateThreadAction.LABEL, this.debugService, this.keybindingService));
 		} else if (element instanceof StackFrame) {
 			this.callStackItemType.set('stackFrame');
-			if (element.thread.session.capabilities.supportsRestartFrame) {
-				actions.push(new RestartFrameAction(RestartFrameAction.ID, RestartFrameAction.LABEL, this.debugService, this.keybindingService));
-			}
-			actions.push(this.instantiationService.createInstance(CopyStackTraceAction, CopyStackTraceAction.ID, CopyStackTraceAction.LABEL));
 		} else {
 			this.callStackItemType.reset();
 		}
@@ -297,7 +276,8 @@ export class CallStackView extends ViewletPanel {
 		this.contextMenuService.showContextMenu({
 			getAnchor: () => e.anchor,
 			getActions: () => {
-				fillInContextMenuActions(this.contributedContextMenu, { arg: this.getContextForContributedActions(element) }, actions, this.contextMenuService);
+				const actions: IAction[] = [];
+				fillInContextMenuActions(this.contributedContextMenu, { arg: this.getContextForContributedActions(element), shouldForwardArgs: true }, actions, this.contextMenuService);
 				return actions;
 			},
 			getActionsContext: () => element
@@ -315,6 +295,9 @@ export class CallStackView extends ViewletPanel {
 		if (element instanceof Thread) {
 			return element.threadId;
 		}
+		if (isDebugSession(element)) {
+			return element.getId();
+		}
 
 		return undefined;
 	}

src/vs/workbench/contrib/debug/browser/debugCommands.ts

@@ -9,8 +9,8 @@ import { List } from 'vs/base/browser/ui/list/listWidget';
 import { KeybindingsRegistry, KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';
 import { IListService } from 'vs/platform/list/browser/listService';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
-import { IDebugService, IEnablement, CONTEXT_BREAKPOINTS_FOCUSED, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, CONTEXT_VARIABLES_FOCUSED, EDITOR_CONTRIBUTION_ID, IDebugEditorContribution, CONTEXT_IN_DEBUG_MODE, CONTEXT_EXPRESSION_SELECTED, CONTEXT_BREAKPOINT_SELECTED, IConfig } from 'vs/workbench/contrib/debug/common/debug';
-import { Expression, Variable, Breakpoint, FunctionBreakpoint } from 'vs/workbench/contrib/debug/common/debugModel';
+import { IDebugService, IEnablement, CONTEXT_BREAKPOINTS_FOCUSED, CONTEXT_WATCH_EXPRESSIONS_FOCUSED, CONTEXT_VARIABLES_FOCUSED, EDITOR_CONTRIBUTION_ID, IDebugEditorContribution, CONTEXT_IN_DEBUG_MODE, CONTEXT_EXPRESSION_SELECTED, CONTEXT_BREAKPOINT_SELECTED, IConfig, IStackFrame, IThread, IDebugSession, CONTEXT_DEBUG_STATE, REPL_ID } from 'vs/workbench/contrib/debug/common/debug';
+import { Expression, Variable, Breakpoint, FunctionBreakpoint, Thread } from 'vs/workbench/contrib/debug/common/debugModel';
 import { IExtensionsViewlet, VIEWLET_ID as EXTENSIONS_VIEWLET_ID } from 'vs/workbench/contrib/extensions/common/extensions';
 import { IViewletService } from 'vs/workbench/services/viewlet/browser/viewlet';
 import { ICodeEditor, isCodeEditor } from 'vs/editor/browser/editorBrowser';
@@ -25,12 +25,188 @@ import { ServicesAccessor } from 'vs/editor/browser/editorExtensions';
 import { PanelFocusContext } from 'vs/workbench/common/panel';
 import { CommandsRegistry } from 'vs/platform/commands/common/commands';
 import { onUnexpectedError } from 'vs/base/common/errors';
+import { ITextResourcePropertiesService } from 'vs/editor/common/services/resourceConfiguration';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
+import { IHistoryService } from 'vs/workbench/services/history/common/history';
+import { startDebugging } from 'vs/workbench/contrib/debug/common/debugUtils';
+import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 
 export const ADD_CONFIGURATION_ID = 'debug.addConfiguration';
 export const TOGGLE_INLINE_BREAKPOINT_ID = 'editor.debug.action.toggleInlineBreakpoint';
+export const COPY_STACK_TRACE_ID = 'debug.copyStackTrace';
+export const REVERSE_CONTINUE_ID = 'workbench.action.debug.reverseContinue';
+export const STEP_BACK_ID = 'workbench.action.debug.stepBack';
+export const RESTART_SESSION_ID = 'workbench.action.debug.restart';
+export const TERMINATE_THREAD_ID = 'workbench.action.debug.terminateThread';
+export const STEP_OVER_ID = 'workbench.action.debug.stepOver';
+export const STEP_INTO_ID = 'workbench.action.debug.stepInto';
+export const STEP_OUT_ID = 'workbench.action.debug.stepOut';
+export const PAUSE_ID = 'workbench.action.debug.pause';
+export const DISCONNECT_ID = 'workbench.action.debug.disconnect';
+export const STOP_ID = 'workbench.action.debug.stop';
+export const RESTART_FRAME_ID = 'workbench.action.debug.restartFrame';
+export const CONTINUE_ID = 'workbench.action.debug.continue';
+export const FOCUS_REPL_ID = 'workbench.debug.action.focusRepl';
+
+function getThreadAndRun(accessor: ServicesAccessor, thread: IThread | undefined, run: (thread: IThread) => Promise<void>, ): void {
+	const debugService = accessor.get(IDebugService);
+	if (!(thread instanceof Thread)) {
+		thread = debugService.getViewModel().focusedThread;
+	}
+
+	if (thread) {
+		run(thread).then(undefined, onUnexpectedError);
+	}
+}
 
 export function registerCommands(): void {
 
+	CommandsRegistry.registerCommand({
+		id: COPY_STACK_TRACE_ID,
+		handler: (accessor: ServicesAccessor, _: string, frame: IStackFrame) => {
+			const textResourcePropertiesService = accessor.get(ITextResourcePropertiesService);
+			const clipboardService = accessor.get(IClipboardService);
+			const eol = textResourcePropertiesService.getEOL(frame.source.uri);
+			clipboardService.writeText(frame.thread.getCallStack().map(sf => sf.toString()).join(eol));
+		}
+	});
+
+	CommandsRegistry.registerCommand({
+		id: REVERSE_CONTINUE_ID,
+		handler: (accessor: ServicesAccessor, _: string, thread: IThread | undefined) => {
+			getThreadAndRun(accessor, thread, thread => thread.reverseContinue());
+		}
+	});
+
+	CommandsRegistry.registerCommand({
+		id: STEP_BACK_ID,
+		handler: (accessor: ServicesAccessor, _: string, thread: IThread | undefined) => {
+			getThreadAndRun(accessor, thread, thread => thread.stepBack());
+		}
+	});
+
+	CommandsRegistry.registerCommand({
+		id: TERMINATE_THREAD_ID,
+		handler: (accessor: ServicesAccessor, _: string, thread: IThread | undefined) => {
+			getThreadAndRun(accessor, thread, thread => thread.terminate());
+		}
+	});
+
+	KeybindingsRegistry.registerCommandAndKeybindingRule({
+		id: RESTART_SESSION_ID,
+		weight: KeybindingWeight.WorkbenchContrib,
+		primary: KeyMod.Shift | KeyMod.CtrlCmd | KeyCode.F5,
+		when: CONTEXT_IN_DEBUG_MODE,
+		handler: (accessor: ServicesAccessor, _: string, session: IDebugSession | undefined) => {
+			const debugService = accessor.get(IDebugService);
+			if (!session || !session.getId) {
+				session = debugService.getViewModel().focusedSession;
+			}
+
+			if (!session) {
+				const historyService = accessor.get(IHistoryService);
+				startDebugging(debugService, historyService, false);
+			} else {
+				session.removeReplExpressions();
+				debugService.restartSession(session).then(undefined, onUnexpectedError);
+			}
+		}
+	});
+
+	KeybindingsRegistry.registerCommandAndKeybindingRule({
+		id: STEP_OVER_ID,
+		weight: KeybindingWeight.WorkbenchContrib,
+		primary: KeyCode.F10,
+		when: CONTEXT_DEBUG_STATE.isEqualTo('stopped'),
+		handler: (accessor: ServicesAccessor, _: string, thread: IThread | undefined) => {
+			getThreadAndRun(accessor, thread, thread => thread.next());
+		}
+	});
+
+	KeybindingsRegistry.registerCommandAndKeybindingRule({
+		id: STEP_INTO_ID,
+		weight: KeybindingWeight.WorkbenchContrib,
+		primary: KeyCode.F11,
+		when: CONTEXT_DEBUG_STATE.isEqualTo('stopped'),
+		handler: (accessor: ServicesAccessor, _: string, thread: IThread | undefined) => {
+			getThreadAndRun(accessor, thread, thread => thread.stepIn());
+		}
+	});
+
+	KeybindingsRegistry.registerCommandAndKeybindingRule({
+		id: STEP_OUT_ID,
+		weight: KeybindingWeight.WorkbenchContrib,
+		primary: KeyMod.Shift | KeyCode.F11,
+		when: CONTEXT_DEBUG_STATE.isEqualTo('stopped'),
+		handler: (accessor: ServicesAccessor, _: string, thread: IThread | undefined) => {
+			getThreadAndRun(accessor, thread, thread => thread.stepOut());
+		}
+	});
+
+	KeybindingsRegistry.registerCommandAndKeybindingRule({
+		id: PAUSE_ID,
+		weight: KeybindingWeight.WorkbenchContrib,
+		primary: KeyCode.F6,
+		when: CONTEXT_DEBUG_STATE.isEqualTo('running'),
+		handler: (accessor: ServicesAccessor, _: string, thread: IThread | undefined) => {
+			getThreadAndRun(accessor, thread, thread => thread.pause());
+		}
+	});
+
+	CommandsRegistry.registerCommand({
+		id: DISCONNECT_ID,
+		handler: (accessor: ServicesAccessor) => {
+			const debugService = accessor.get(IDebugService);
+			const session = debugService.getViewModel().focusedSession;
+			debugService.stopSession(session).then(undefined, onUnexpectedError);
+		}
+	});
+
+	KeybindingsRegistry.registerCommandAndKeybindingRule({
+		id: STOP_ID,
+		weight: KeybindingWeight.WorkbenchContrib,
+		primary: KeyMod.Shift | KeyCode.F5,
+		when: CONTEXT_IN_DEBUG_MODE,
+		handler: (accessor: ServicesAccessor, _: string, session: IDebugSession | undefined) => {
+			const debugService = accessor.get(IDebugService);
+			if (!session || !session.getId) {
+				session = debugService.getViewModel().focusedSession;
+			}
+
+			debugService.stopSession(session).then(undefined, onUnexpectedError);
+		}
+	});
+
+	CommandsRegistry.registerCommand({
+		id: RESTART_FRAME_ID,
+		handler: (accessor: ServicesAccessor, _: string, frame: IStackFrame | undefined) => {
+			const debugService = accessor.get(IDebugService);
+			if (!frame) {
+				frame = debugService.getViewModel().focusedStackFrame;
+			}
+
+			return frame!.restart();
+		}
+	});
+
+	KeybindingsRegistry.registerCommandAndKeybindingRule({
+		id: CONTINUE_ID,
+		weight: KeybindingWeight.WorkbenchContrib,
+		primary: KeyCode.F5,
+		when: CONTEXT_IN_DEBUG_MODE,
+		handler: (accessor: ServicesAccessor, _: string, thread: IThread | undefined) => {
+			getThreadAndRun(accessor, thread, thread => thread.continue());
+		}
+	});
+
+	CommandsRegistry.registerCommand({
+		id: FOCUS_REPL_ID,
+		handler: (accessor) => {
+			const panelService = accessor.get(IPanelService);
+			panelService.openPanel(REPL_ID, true);
+		}
+	});
+
 	CommandsRegistry.registerCommand({
 		id: 'debug.startFromConfig',
 		handler: (accessor, config: IConfig) => {

src/vs/workbench/contrib/debug/browser/debugViewlet.ts

@@ -9,8 +9,8 @@ import { IAction } from 'vs/base/common/actions';
 import * as DOM from 'vs/base/browser/dom';
 import { IActionItem } from 'vs/base/browser/ui/actionbar/actionbar';
 import { ViewContainerViewlet } from 'vs/workbench/browser/parts/views/viewsViewlet';
-import { IDebugService, VIEWLET_ID, State, BREAKPOINTS_VIEW_ID, IDebugConfiguration } from 'vs/workbench/contrib/debug/common/debug';
-import { StartAction, ToggleReplAction, ConfigureAction, SelectAndStartAction, FocusSessionAction } from 'vs/workbench/contrib/debug/browser/debugActions';
+import { IDebugService, VIEWLET_ID, State, BREAKPOINTS_VIEW_ID, IDebugConfiguration, REPL_ID } from 'vs/workbench/contrib/debug/common/debug';
+import { StartAction, ConfigureAction, SelectAndStartAction, FocusSessionAction } from 'vs/workbench/contrib/debug/browser/debugActions';
 import { StartDebugActionItem, FocusSessionActionItem } from 'vs/workbench/contrib/debug/browser/debugActionItems';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
@@ -31,6 +31,8 @@ import { IMenu, MenuId, IMenuService, MenuItemAction } from 'vs/platform/actions
 import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { MenuItemActionItem } from 'vs/platform/actions/browser/menuItemActionItem';
 import { INotificationService } from 'vs/platform/notification/common/notification';
+import { TogglePanelAction } from 'vs/workbench/browser/panel';
+import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
 
 export class DebugViewlet extends ViewContainerViewlet {
 
@@ -193,3 +195,15 @@ export class DebugViewlet extends ViewContainerViewlet {
 		}
 	}
 }
+
+class ToggleReplAction extends TogglePanelAction {
+	static readonly ID = 'debug.toggleRepl';
+	static LABEL = nls.localize({ comment: ['Debug is a noun in this context, not a verb.'], key: 'debugConsoleAction' }, 'Debug Console');
+
+	constructor(id: string, label: string,
+		@IWorkbenchLayoutService layoutService: IWorkbenchLayoutService,
+		@IPanelService panelService: IPanelService
+	) {
+		super(id, label, REPL_ID, panelService, layoutService, 'debug-action toggle-repl');
+	}
+}

src/vs/workbench/contrib/debug/browser/repl.ts

@@ -52,7 +52,6 @@ import { renderExpressionValue } from 'vs/workbench/contrib/debug/browser/baseDe
 import { handleANSIOutput } from 'vs/workbench/contrib/debug/browser/debugANSIHandling';
 import { ILabelService } from 'vs/platform/label/common/label';
 import { LinkDetector } from 'vs/workbench/contrib/debug/browser/linkDetector';
-import { ReplCollapseAllAction, CopyAction } from 'vs/workbench/contrib/debug/browser/debugActions';
 import { Separator } from 'vs/base/browser/ui/actionbar/actionbar';
 import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
 import { removeAnsiEscapeCodes } from 'vs/base/common/strings';
@@ -452,12 +451,19 @@ export class Repl extends Panel implements IPrivateReplService, IHistoryNavigati
 
 	private onContextMenu(e: ITreeContextMenuEvent<IReplElement>): void {
 		const actions: IAction[] = [];
-		actions.push(new CopyAction(CopyAction.ID, CopyAction.LABEL, this.clipboardService));
+		actions.push(new Action('debug.replCopy', nls.localize('copy', "Copy"), undefined, true, () => {
+			this.clipboardService.writeText(window.getSelection().toString());
+			return Promise.resolve();
+		}));
 		actions.push(new Action('workbench.debug.action.copyAll', nls.localize('copyAll', "Copy All"), undefined, true, () => {
 			this.clipboardService.writeText(this.getVisibleContent());
 			return Promise.resolve(undefined);
 		}));
-		actions.push(new ReplCollapseAllAction(this.tree, this.replInput));
+		actions.push(new Action('debug.collapseRepl', nls.localize('collapse', "Collapse All"), undefined, true, () => {
+			this.tree.collapseAll();
+			this.replInput.focus();
+			return Promise.resolve();
+		}));
 		actions.push(new Separator());
 		actions.push(this.clearReplAction);
 

src/vs/workbench/contrib/debug/browser/variablesView.ts

@@ -13,8 +13,8 @@ import { Variable, Scope } from 'vs/workbench/contrib/debug/common/debugModel';
 import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { renderViewTree, renderVariable, IInputBoxOptions, AbstractExpressionsRenderer, IExpressionTemplateData } from 'vs/workbench/contrib/debug/browser/baseDebugView';
-import { IAction } from 'vs/base/common/actions';
-import { SetValueAction, AddToWatchExpressionsAction, CopyValueAction, CopyEvaluatePathAction } from 'vs/workbench/contrib/debug/browser/debugActions';
+import { IAction, Action } from 'vs/base/common/actions';
+import { CopyValueAction } from 'vs/workbench/contrib/debug/browser/debugActions';
 import { Separator } from 'vs/base/browser/ui/actionbar/actionbar';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IViewletPanelOptions, ViewletPanel } from 'vs/workbench/browser/parts/views/panelViewlet';
@@ -27,6 +27,7 @@ import { WorkbenchAsyncDataTree } from 'vs/platform/list/browser/listService';
 import { onUnexpectedError } from 'vs/base/common/errors';
 import { FuzzyScore, createMatches } from 'vs/base/common/filters';
 import { HighlightedLabel, IHighlight } from 'vs/base/browser/ui/highlightedlabel/highlightedLabel';
+import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService';
 
 const $ = dom.$;
 
@@ -45,6 +46,7 @@ export class VariablesView extends ViewletPanel {
 		@IKeybindingService keybindingService: IKeybindingService,
 		@IConfigurationService configurationService: IConfigurationService,
 		@IInstantiationService private readonly instantiationService: IInstantiationService,
+		@IClipboardService private readonly clipboardService: IClipboardService
 	) {
 		super({ ...(options as IViewletPanelOptions), ariaHeaderLabel: nls.localize('variablesSection', "Variables Section") }, keybindingService, contextMenuService, configurationService);
 
@@ -129,20 +131,33 @@ export class VariablesView extends ViewletPanel {
 	}
 
 	private onContextMenu(e: ITreeContextMenuEvent<IExpression | IScope>): void {
-		const element = e.element;
-		if (element instanceof Variable && !!element.value) {
+		const variable = e.element;
+		if (variable instanceof Variable && !!variable.value) {
 			const actions: IAction[] = [];
-			const variable = element as Variable;
-			actions.push(new SetValueAction(SetValueAction.ID, SetValueAction.LABEL, variable, this.debugService, this.keybindingService));
+			const session = this.debugService.getViewModel().focusedSession;
+			if (session && session.capabilities.supportsSetVariable) {
+				actions.push(new Action('workbench.setValue', nls.localize('setValue', "Set Value"), undefined, true, () => {
+					this.debugService.getViewModel().setSelectedExpression(variable);
+					return Promise.resolve();
+				}));
+			}
 			actions.push(this.instantiationService.createInstance(CopyValueAction, CopyValueAction.ID, CopyValueAction.LABEL, variable, 'variables'));
-			actions.push(this.instantiationService.createInstance(CopyEvaluatePathAction, CopyEvaluatePathAction.ID, CopyEvaluatePathAction.LABEL, variable));
-			actions.push(new Separator());
-			actions.push(new AddToWatchExpressionsAction(AddToWatchExpressionsAction.ID, AddToWatchExpressionsAction.LABEL, variable, this.debugService, this.keybindingService));
+			if (variable.evaluateName) {
+				actions.push(new Action('debug.copyEvaluatePath', nls.localize('copyAsExpression', "Copy as Expression"), undefined, true, () => {
+					this.clipboardService.writeText(variable.evaluateName!);
+					return Promise.resolve();
+				}));
+				actions.push(new Separator());
+				actions.push(new Action('debug.addToWatchExpressions', nls.localize('addToWatchExpressions', "Add to Watch"), undefined, true, () => {
+					this.debugService.addWatchExpression(variable.evaluateName);
+					return Promise.resolve(undefined);
+				}));
+			}
 
 			this.contextMenuService.showContextMenu({
 				getAnchor: () => e.anchor,
 				getActions: () => actions,
-				getActionsContext: () => element
+				getActionsContext: () => variable
 			});
 		}
 	}

src/vs/workbench/contrib/debug/browser/watchExpressionsView.ts

@@ -10,11 +10,11 @@ import { CollapseAction } from 'vs/workbench/browser/viewlet';
 import { IViewletViewOptions } from 'vs/workbench/browser/parts/views/viewsViewlet';
 import { IDebugService, IExpression, CONTEXT_WATCH_EXPRESSIONS_FOCUSED } from 'vs/workbench/contrib/debug/common/debug';
 import { Expression, Variable } from 'vs/workbench/contrib/debug/common/debugModel';
-import { AddWatchExpressionAction, RemoveAllWatchExpressionsAction, EditWatchExpressionAction, RemoveWatchExpressionAction, CopyValueAction } from 'vs/workbench/contrib/debug/browser/debugActions';
+import { AddWatchExpressionAction, RemoveAllWatchExpressionsAction, CopyValueAction } from 'vs/workbench/contrib/debug/browser/debugActions';
 import { IContextMenuService } from 'vs/platform/contextview/browser/contextView';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
-import { IAction } from 'vs/base/common/actions';
+import { IAction, Action } from 'vs/base/common/actions';
 import { Separator } from 'vs/base/browser/ui/actionbar/actionbar';
 import { renderExpressionValue, renderViewTree, IInputBoxOptions, AbstractExpressionsRenderer, IExpressionTemplateData } from 'vs/workbench/contrib/debug/browser/baseDebugView';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
@@ -144,13 +144,19 @@ export class WatchExpressionsView extends ViewletPanel {
 		if (element instanceof Expression) {
 			const expression = <Expression>element;
 			actions.push(new AddWatchExpressionAction(AddWatchExpressionAction.ID, AddWatchExpressionAction.LABEL, this.debugService, this.keybindingService));
-			actions.push(new EditWatchExpressionAction(EditWatchExpressionAction.ID, EditWatchExpressionAction.LABEL, this.debugService, this.keybindingService));
+			actions.push(new Action('debug.editWatchExpression', nls.localize('editWatchExpression', "Edit Expression"), undefined, true, () => {
+				this.debugService.getViewModel().setSelectedExpression(expression);
+				return Promise.resolve();
+			}));
 			if (!expression.hasChildren) {
 				actions.push(this.instantiationService.createInstance(CopyValueAction, CopyValueAction.ID, CopyValueAction.LABEL, expression.value, 'watch', this.debugService));
 			}
 			actions.push(new Separator());
 
-			actions.push(new RemoveWatchExpressionAction(RemoveWatchExpressionAction.ID, RemoveWatchExpressionAction.LABEL, this.debugService, this.keybindingService));
+			actions.push(new Action('debug.removeWatchExpression', nls.localize('removeWatchExpression', "Remove Expression"), undefined, true, () => {
+				this.debugService.removeWatchExpressions(expression.getId());
+				return Promise.resolve();
+			}));
 			actions.push(new RemoveAllWatchExpressionsAction(RemoveAllWatchExpressionsAction.ID, RemoveAllWatchExpressionsAction.LABEL, this.debugService, this.keybindingService));
 		} else {
 			actions.push(new AddWatchExpressionAction(AddWatchExpressionAction.ID, AddWatchExpressionAction.LABEL, this.debugService, this.keybindingService));