@theia/debug 1.18.0 → 1.21.0-next.12

package/src/browser/debug-frontend-application-contribution.ts

@@ -51,6 +51,7 @@ import { ColorContribution } from '@theia/core/lib/browser/color-application-con
 import { ColorRegistry } from '@theia/core/lib/browser/color-registry';
 import { DebugFunctionBreakpoint } from './model/debug-function-breakpoint';
 import { DebugBreakpoint } from './model/debug-breakpoint';
+import { nls } from '@theia/core/lib/common/nls';
 
 export namespace DebugMenus {
     export const DEBUG = [...MAIN_MENU_BAR, '6_debug'];
@@ -63,214 +64,242 @@ export namespace DebugMenus {
     export const DEBUG_BREAKPOINTS = [...DEBUG, 'f_breakpoints'];
 }
 
+function nlsEditBreakpoint(breakpointKey: string, breakpoint: string): string {
+    return nls.localizeByDefault('Edit {0}...', nls.localize(`vscode/breakpointEditorContribution/${breakpointKey}`, breakpoint));
+}
+
+function nlsRemoveBreakpoint(breakpointKey: string, breakpoint: string): string {
+    return nls.localizeByDefault('Remove {0}',
+        nls.localize(`vscode/breakpointEditorContribution/${breakpointKey}`, breakpoint));
+}
+
+function nlsEnableBreakpoint(breakpointKey: string, breakpoint: string): string {
+    return nls.localizeByDefault('Enable {0}',
+        nls.localize(`vscode/breakpointEditorContribution/${breakpointKey}`, breakpoint));
+}
+
+function nlsDisableBreakpoint(breakpointKey: string, breakpoint: string): string {
+    return nls.localizeByDefault('Disable {0}',
+        nls.localize(`vscode/breakpointEditorContribution/${breakpointKey}`, breakpoint));
+}
+
 export namespace DebugCommands {
 
     export const DEBUG_CATEGORY = 'Debug';
+    export const DEBUG_CATEGORY_KEY = nls.getDefaultKey(DEBUG_CATEGORY);
 
-    export const START: Command = {
+    export const START = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.debug.start',
         category: DEBUG_CATEGORY,
         label: 'Start Debugging',
         iconClass: codicon('debug-alt')
-    };
-    export const START_NO_DEBUG: Command = {
+    });
+    export const START_NO_DEBUG = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.debug.run',
-        label: 'Debug: Start Without Debugging'
-    };
-    export const STOP: Command = {
+        category: DEBUG_CATEGORY,
+        label: 'Start Without Debugging'
+    });
+    export const STOP = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.debug.stop',
         category: DEBUG_CATEGORY,
-        label: 'Stop Debugging',
+        label: 'Stop',
         iconClass: codicon('debug-stop')
-    };
-    export const RESTART: Command = {
+    });
+    export const RESTART = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.debug.restart',
         category: DEBUG_CATEGORY,
-        label: 'Restart Debugging',
-    };
+        label: 'Restart',
+    });
 
-    export const OPEN_CONFIGURATIONS = {
+    export const OPEN_CONFIGURATIONS = Command.toDefaultLocalizedCommand({
         id: 'debug.configurations.open',
-        label: 'Debug: Open Configurations'
-    };
-    export const ADD_CONFIGURATION = {
+        category: DEBUG_CATEGORY,
+        label: 'Open Configurations'
+    });
+    export const ADD_CONFIGURATION = Command.toDefaultLocalizedCommand({
         id: 'debug.configurations.add',
-        label: 'Debug: Add Configuration...'
-    };
+        category: DEBUG_CATEGORY,
+        label: 'Add Configuration...'
+    });
 
-    export const STEP_OVER: Command = {
+    export const STEP_OVER = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.debug.stepOver',
         category: DEBUG_CATEGORY,
         label: 'Step Over',
         iconClass: codicon('debug-step-over')
-    };
-    export const STEP_INTO: Command = {
+    });
+    export const STEP_INTO = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.debug.stepInto',
         category: DEBUG_CATEGORY,
         label: 'Step Into',
         iconClass: codicon('debug-step-into')
-    };
-    export const STEP_OUT: Command = {
+    });
+    export const STEP_OUT = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.debug.stepOut',
         category: DEBUG_CATEGORY,
         label: 'Step Out',
         iconClass: codicon('debug-step-out')
-    };
-    export const CONTINUE: Command = {
+    });
+    export const CONTINUE = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.debug.continue',
         category: DEBUG_CATEGORY,
         label: 'Continue',
         iconClass: codicon('debug-continue')
-    };
-    export const PAUSE: Command = {
+    });
+    export const PAUSE = Command.toDefaultLocalizedCommand({
         id: 'workbench.action.debug.pause',
         category: DEBUG_CATEGORY,
         label: 'Pause',
         iconClass: codicon('debug-pause')
-    };
-    export const CONTINUE_ALL: Command = {
+    });
+    export const CONTINUE_ALL = Command.toLocalizedCommand({
         id: 'debug.thread.continue.all',
         category: DEBUG_CATEGORY,
         label: 'Continue All',
         iconClass: codicon('debug-continue')
-    };
-    export const PAUSE_ALL: Command = {
+    }, 'theia/debug/continueAll', DEBUG_CATEGORY_KEY);
+    export const PAUSE_ALL = Command.toLocalizedCommand({
         id: 'debug.thread.pause.all',
         category: DEBUG_CATEGORY,
         label: 'Pause All',
         iconClass: codicon('debug-pause')
-    };
+    }, 'theia/debug/pauseAll', DEBUG_CATEGORY_KEY);
 
-    export const TOGGLE_BREAKPOINT: Command = {
+    export const TOGGLE_BREAKPOINT = Command.toDefaultLocalizedCommand({
         id: 'editor.debug.action.toggleBreakpoint',
         category: DEBUG_CATEGORY,
         label: 'Toggle Breakpoint',
-    };
-    export const INLINE_BREAKPOINT: Command = {
+    });
+    export const INLINE_BREAKPOINT = Command.toDefaultLocalizedCommand({
         id: 'editor.debug.action.inlineBreakpoint',
         category: DEBUG_CATEGORY,
         label: 'Inline Breakpoint',
-    };
-    export const ADD_CONDITIONAL_BREAKPOINT: Command = {
+    });
+    export const ADD_CONDITIONAL_BREAKPOINT = Command.toDefaultLocalizedCommand({
         id: 'debug.breakpoint.add.conditional',
         category: DEBUG_CATEGORY,
         label: 'Add Conditional Breakpoint...',
-    };
-    export const ADD_LOGPOINT: Command = {
+    });
+    export const ADD_LOGPOINT = Command.toDefaultLocalizedCommand({
         id: 'debug.breakpoint.add.logpoint',
         category: DEBUG_CATEGORY,
         label: 'Add Logpoint...',
-    };
-    export const ADD_FUNCTION_BREAKPOINT: Command = {
+    });
+    export const ADD_FUNCTION_BREAKPOINT = Command.toDefaultLocalizedCommand({
         id: 'debug.breakpoint.add.function',
         category: DEBUG_CATEGORY,
-        label: 'Add Function Breakpoint...',
-    };
-    export const ENABLE_ALL_BREAKPOINTS: Command = {
+        label: 'Add Function Breakpoint',
+    });
+    export const ENABLE_ALL_BREAKPOINTS = Command.toDefaultLocalizedCommand({
         id: 'debug.breakpoint.enableAll',
         category: DEBUG_CATEGORY,
         label: 'Enable All Breakpoints',
-    };
-    export const DISABLE_ALL_BREAKPOINTS: Command = {
+    });
+    export const DISABLE_ALL_BREAKPOINTS = Command.toDefaultLocalizedCommand({
         id: 'debug.breakpoint.disableAll',
         category: DEBUG_CATEGORY,
         label: 'Disable All Breakpoints',
-    };
-    export const EDIT_BREAKPOINT: Command = {
+    });
+    export const EDIT_BREAKPOINT = Command.toLocalizedCommand({
         id: 'debug.breakpoint.edit',
         category: DEBUG_CATEGORY,
-        label: 'Edit Breakpoint...',
-    };
-    export const EDIT_LOGPOINT: Command = {
+        originalLabel: 'Edit Breakpoint...',
+        label: nlsEditBreakpoint('breakpoint', 'Breakpoint')
+    }, '', DEBUG_CATEGORY_KEY);
+    export const EDIT_LOGPOINT = Command.toLocalizedCommand({
         id: 'debug.logpoint.edit',
         category: DEBUG_CATEGORY,
-        label: 'Edit Logpoint...',
-    };
-    export const REMOVE_BREAKPOINT: Command = {
+        originalLabel: 'Edit Logpoint...',
+        label: nlsEditBreakpoint('logPoint', 'Logpoint')
+    }, '', DEBUG_CATEGORY_KEY);
+    export const REMOVE_BREAKPOINT = Command.toLocalizedCommand({
         id: 'debug.breakpoint.remove',
         category: DEBUG_CATEGORY,
-        label: 'Remove Breakpoint',
-    };
-    export const REMOVE_LOGPOINT: Command = {
+        originalLabel: 'Remove Breakpoint',
+        label: nlsRemoveBreakpoint('breakpoint', 'Breakpoint')
+    }, '', DEBUG_CATEGORY_KEY);
+    export const REMOVE_LOGPOINT = Command.toLocalizedCommand({
         id: 'debug.logpoint.remove',
         category: DEBUG_CATEGORY,
-        label: 'Remove Logpoint',
-    };
-    export const REMOVE_ALL_BREAKPOINTS: Command = {
+        originalLabel: 'Remove Logpoint',
+        label: nlsRemoveBreakpoint('logPoint', 'Logpoint')
+    }, '', DEBUG_CATEGORY_KEY);
+    export const REMOVE_ALL_BREAKPOINTS = Command.toDefaultLocalizedCommand({
         id: 'debug.breakpoint.removeAll',
         category: DEBUG_CATEGORY,
         label: 'Remove All Breakpoints',
-    };
-    export const TOGGLE_BREAKPOINTS_ENABLED: Command = {
+    });
+    export const TOGGLE_BREAKPOINTS_ENABLED = Command.toLocalizedCommand({
         id: 'debug.breakpoint.toggleEnabled'
-    };
-    export const SHOW_HOVER = {
+    });
+    export const SHOW_HOVER = Command.toDefaultLocalizedCommand({
         id: 'editor.debug.action.showDebugHover',
-        label: 'Debug: Show Hover'
-    };
+        category: DEBUG_CATEGORY,
+        label: 'Show Hover'
+    });
 
-    export const RESTART_FRAME: Command = {
+    export const RESTART_FRAME = Command.toDefaultLocalizedCommand({
         id: 'debug.frame.restart',
         category: DEBUG_CATEGORY,
         label: 'Restart Frame',
-    };
-    export const COPY_CALL_STACK: Command = {
+    });
+    export const COPY_CALL_STACK = Command.toDefaultLocalizedCommand({
         id: 'debug.callStack.copy',
         category: DEBUG_CATEGORY,
         label: 'Copy Call Stack',
-    };
+    });
 
-    export const SET_VARIABLE_VALUE: Command = {
+    export const SET_VARIABLE_VALUE = Command.toDefaultLocalizedCommand({
         id: 'debug.variable.setValue',
         category: DEBUG_CATEGORY,
         label: 'Set Value',
-    };
-    export const COPY_VARIABLE_VALUE: Command = {
+    });
+    export const COPY_VARIABLE_VALUE = Command.toDefaultLocalizedCommand({
         id: 'debug.variable.copyValue',
         category: DEBUG_CATEGORY,
         label: 'Copy Value',
-    };
-    export const COPY_VARIABLE_AS_EXPRESSION: Command = {
+    });
+    export const COPY_VARIABLE_AS_EXPRESSION = Command.toDefaultLocalizedCommand({
         id: 'debug.variable.copyAsExpression',
         category: DEBUG_CATEGORY,
-        label: 'Copy As Expression',
-    };
-    export const WATCH_VARIABLE: Command = {
+        label: 'Copy as Expression',
+    });
+    export const WATCH_VARIABLE = Command.toDefaultLocalizedCommand({
         id: 'debug.variable.watch',
         category: DEBUG_CATEGORY,
         label: 'Add to Watch',
-    };
+    });
 
-    export const ADD_WATCH_EXPRESSION: Command = {
+    export const ADD_WATCH_EXPRESSION = Command.toDefaultLocalizedCommand({
         id: 'debug.watch.addExpression',
         category: DEBUG_CATEGORY,
-        label: 'Add Watch Expression'
-    };
-    export const EDIT_WATCH_EXPRESSION: Command = {
+        label: 'Add Expression'
+    });
+    export const EDIT_WATCH_EXPRESSION = Command.toDefaultLocalizedCommand({
         id: 'debug.watch.editExpression',
         category: DEBUG_CATEGORY,
-        label: 'Edit Watch Expression'
-    };
-    export const COPY_WATCH_EXPRESSION_VALUE: Command = {
+        label: 'Edit Expression'
+    });
+    export const COPY_WATCH_EXPRESSION_VALUE = Command.toLocalizedCommand({
         id: 'debug.watch.copyExpressionValue',
         category: DEBUG_CATEGORY,
-        label: 'Copy Watch Expression Value'
-    };
-    export const REMOVE_WATCH_EXPRESSION: Command = {
+        label: 'Copy Expression Value'
+    }, 'theia/debug/copyExpressionValue', DEBUG_CATEGORY_KEY);
+    export const REMOVE_WATCH_EXPRESSION = Command.toDefaultLocalizedCommand({
         id: 'debug.watch.removeExpression',
         category: DEBUG_CATEGORY,
-        label: 'Remove Watch Expression'
-    };
-    export const COLLAPSE_ALL_WATCH_EXPRESSIONS: Command = {
+        label: 'Remove Expression'
+    });
+    export const COLLAPSE_ALL_WATCH_EXPRESSIONS = Command.toDefaultLocalizedCommand({
         id: 'debug.watch.collapseAllExpressions',
         category: DEBUG_CATEGORY,
-        label: 'Collapse All Watch Expressions'
-    };
-    export const REMOVE_ALL_WATCH_EXPRESSIONS: Command = {
+        label: 'Collapse All'
+    });
+    export const REMOVE_ALL_WATCH_EXPRESSIONS = Command.toDefaultLocalizedCommand({
         id: 'debug.watch.removeAllExpressions',
         category: DEBUG_CATEGORY,
-        label: 'Remove All Watch Expressions'
-    };
+        label: 'Remove All Expressions'
+    });
 }
 export namespace DebugThreadContextCommands {
     export const STEP_OVER = {
@@ -478,6 +507,10 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
         this.watchManager.save();
     }
 
+    onWillStop(): boolean {
+        return this.preference['debug.confirmOnExit'] === 'always' && !!this.manager.currentSession;
+    }
+
     registerMenus(menus: MenuModelRegistry): void {
         super.registerMenus(menus);
         const registerMenuActions = (menuPath: string[], ...commands: Command[]) => {
@@ -493,7 +526,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             }
         };
 
-        menus.registerSubmenu(DebugMenus.DEBUG, 'Run');
+        menus.registerSubmenu(DebugMenus.DEBUG, nls.localizeByDefault('Run'));
         registerMenuActions(DebugMenus.DEBUG_CONTROLS,
             DebugCommands.START,
             DebugCommands.START_NO_DEBUG,
@@ -518,7 +551,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
         registerMenuActions(DebugMenus.DEBUG_BREAKPOINT,
             DebugCommands.TOGGLE_BREAKPOINT
         );
-        menus.registerSubmenu(DebugMenus.DEBUG_NEW_BREAKPOINT, 'New Breakpoint');
+        menus.registerSubmenu(DebugMenus.DEBUG_NEW_BREAKPOINT, nls.localizeByDefault('New Breakpoint'));
         registerMenuActions(DebugMenus.DEBUG_NEW_BREAKPOINT,
             DebugCommands.ADD_CONDITIONAL_BREAKPOINT,
             DebugCommands.INLINE_BREAKPOINT,
@@ -541,15 +574,15 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             { ...DebugCommands.CONTINUE_ALL, ...DebugSessionContextCommands.CONTINUE_ALL }
         );
         registerMenuActions(DebugThreadsWidget.TERMINATE_MENU,
-            { ...DebugCommands.RESTART, ...DebugSessionContextCommands.RESTART, label: 'Restart' },
-            { ...DebugCommands.STOP, ...DebugSessionContextCommands.STOP, label: 'Stop' },
-            { ...DebugThreadContextCommands.TERMINATE, label: 'Terminate Thread' }
+            { ...DebugCommands.RESTART, ...DebugSessionContextCommands.RESTART },
+            { ...DebugCommands.STOP, ...DebugSessionContextCommands.STOP },
+            { ...DebugThreadContextCommands.TERMINATE, label: nls.localizeByDefault('Terminate Thread') }
         );
         registerMenuActions(DebugThreadsWidget.OPEN_MENU,
-            { ...DebugSessionContextCommands.REVEAL, label: 'Reveal' },
-            { ...DebugSessionContextCommands.OPEN_LEFT, label: 'Open Left' },
-            { ...DebugSessionContextCommands.OPEN_RIGHT, label: 'Open Right' },
-            { ...DebugSessionContextCommands.OPEN_BOTTOM, label: 'Open Bottom' }
+            { ...DebugSessionContextCommands.REVEAL, label: nls.localize('theia/debug/reveal', 'Reveal') },
+            { ...DebugSessionContextCommands.OPEN_LEFT, label: nls.localize('theia/debug/openLeft', 'Open Left') },
+            { ...DebugSessionContextCommands.OPEN_RIGHT, label: nls.localize('theia/debug/openRight', 'Open Right') },
+            { ...DebugSessionContextCommands.OPEN_BOTTOM, label: nls.localize('theia/debug/openBottom', 'Open Bottom') }
         );
 
         registerMenuActions(DebugStackFramesWidget.CONTEXT_MENU,
@@ -567,12 +600,12 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
         );
 
         registerMenuActions(DebugWatchWidget.EDIT_MENU,
-            { ...DebugCommands.EDIT_WATCH_EXPRESSION, label: 'Edit Expression' },
-            { ...DebugCommands.COPY_WATCH_EXPRESSION_VALUE, label: 'Copy Value' }
+            DebugCommands.EDIT_WATCH_EXPRESSION,
+            DebugCommands.COPY_WATCH_EXPRESSION_VALUE
         );
         registerMenuActions(DebugWatchWidget.REMOVE_MENU,
-            { ...DebugCommands.REMOVE_WATCH_EXPRESSION, label: 'Remove Expression' },
-            { ...DebugCommands.REMOVE_ALL_WATCH_EXPRESSIONS, label: 'Remove All Expressions' }
+            DebugCommands.REMOVE_WATCH_EXPRESSION,
+            DebugCommands.REMOVE_ALL_WATCH_EXPRESSIONS
         );
 
         registerMenuActions(DebugBreakpointsWidget.EDIT_MENU,
@@ -590,17 +623,17 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
         );
 
         registerMenuActions(DebugEditorModel.CONTEXT_MENU,
-            { ...DebugEditorContextCommands.ADD_BREAKPOINT, label: 'Add Breakpoint' },
+            { ...DebugEditorContextCommands.ADD_BREAKPOINT, label: nls.localizeByDefault('Add Breakpoint') },
             { ...DebugEditorContextCommands.ADD_CONDITIONAL_BREAKPOINT, label: DebugCommands.ADD_CONDITIONAL_BREAKPOINT.label },
             { ...DebugEditorContextCommands.ADD_LOGPOINT, label: DebugCommands.ADD_LOGPOINT.label },
             { ...DebugEditorContextCommands.REMOVE_BREAKPOINT, label: DebugCommands.REMOVE_BREAKPOINT.label },
             { ...DebugEditorContextCommands.EDIT_BREAKPOINT, label: DebugCommands.EDIT_BREAKPOINT.label },
-            { ...DebugEditorContextCommands.ENABLE_BREAKPOINT, label: 'Enable Breakpoint' },
-            { ...DebugEditorContextCommands.DISABLE_BREAKPOINT, label: 'Disable Breakpoint' },
+            { ...DebugEditorContextCommands.ENABLE_BREAKPOINT, label: nlsEnableBreakpoint('breakpoint', 'Breakpoint') },
+            { ...DebugEditorContextCommands.DISABLE_BREAKPOINT, label: nlsDisableBreakpoint('breakpoint', 'Breakpoint') },
             { ...DebugEditorContextCommands.REMOVE_LOGPOINT, label: DebugCommands.REMOVE_LOGPOINT.label },
             { ...DebugEditorContextCommands.EDIT_LOGPOINT, label: DebugCommands.EDIT_LOGPOINT.label },
-            { ...DebugEditorContextCommands.ENABLE_LOGPOINT, label: 'Enable Logpoint' },
-            { ...DebugEditorContextCommands.DISABLE_LOGPOINT, label: 'Disable Logpoint' }
+            { ...DebugEditorContextCommands.ENABLE_LOGPOINT, label: nlsEnableBreakpoint('logPoint', 'Logpoint') },
+            { ...DebugEditorContextCommands.DISABLE_LOGPOINT, label: nlsDisableBreakpoint('logPoint', 'Logpoint') }
         );
     }
 
@@ -613,11 +646,11 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             execute: (config?: DebugSessionOptions) => this.start(true, config)
         });
         registry.registerCommand(DebugCommands.STOP, {
-            execute: () => this.manager.terminateSessions(),
+            execute: () => this.manager.terminateSession(),
             isEnabled: () => this.manager.state !== DebugState.Inactive
         });
         registry.registerCommand(DebugCommands.RESTART, {
-            execute: () => this.manager.restartSessions(),
+            execute: () => this.manager.restartSession(),
             isEnabled: () => this.manager.state !== DebugState.Inactive
         });
 
@@ -689,12 +722,12 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
         });
 
         registry.registerCommand(DebugSessionContextCommands.STOP, {
-            execute: () => this.selectedSession && this.selectedSession.terminate(),
+            execute: () => this.selectedSession && this.manager.terminateSession(this.selectedSession),
             isEnabled: () => !!this.selectedSession && this.selectedSession.state !== DebugState.Inactive,
             isVisible: () => !this.selectedThread
         });
         registry.registerCommand(DebugSessionContextCommands.RESTART, {
-            execute: () => this.selectedSession && this.manager.restart(this.selectedSession),
+            execute: () => this.selectedSession && this.manager.restartSession(this.selectedSession),
             isEnabled: () => !!this.selectedSession && this.selectedSession.state !== DebugState.Inactive,
             isVisible: () => !this.selectedThread
         });
@@ -1074,7 +1107,9 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             priority: 1
         };
         const updateToggleBreakpointsEnabled = () => {
-            const tooltip = this.breakpointManager.breakpointsEnabled ? 'Deactivate Breakpoints' : 'Activate Breakpoints';
+            const activateBreakpoints = nls.localizeByDefault('Enable All Breakpoints');
+            const deactivateBreakpoints = nls.localizeByDefault('Disable All Breakpoints');
+            const tooltip = this.breakpointManager.breakpointsEnabled ? deactivateBreakpoints : activateBreakpoints;
             if (toggleBreakpointsEnabled.tooltip !== tooltip) {
                 toggleBreakpointsEnabled.tooltip = tooltip;
                 onDidChangeToggleBreakpointsEnabled.fire(undefined);
@@ -1084,7 +1119,7 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             id: DebugCommands.ADD_FUNCTION_BREAKPOINT.id,
             command: DebugCommands.ADD_FUNCTION_BREAKPOINT.id,
             icon: codicon('add'),
-            tooltip: 'Add Function Breakpoint'
+            tooltip: DebugCommands.ADD_FUNCTION_BREAKPOINT.label
         });
         updateToggleBreakpointsEnabled();
         this.breakpointManager.onDidChangeBreakpoints(updateToggleBreakpointsEnabled);
@@ -1100,20 +1135,20 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
             id: DebugCommands.ADD_WATCH_EXPRESSION.id,
             command: DebugCommands.ADD_WATCH_EXPRESSION.id,
             icon: codicon('add'),
-            tooltip: 'Add Expression'
+            tooltip: DebugCommands.ADD_WATCH_EXPRESSION.label
         });
         toolbar.registerItem({
             id: DebugCommands.COLLAPSE_ALL_WATCH_EXPRESSIONS.id,
             command: DebugCommands.COLLAPSE_ALL_WATCH_EXPRESSIONS.id,
             icon: codicon('collapse-all'),
-            tooltip: 'Collapse All',
+            tooltip: DebugCommands.COLLAPSE_ALL_WATCH_EXPRESSIONS.label,
             priority: 1
         });
         toolbar.registerItem({
             id: DebugCommands.REMOVE_ALL_WATCH_EXPRESSIONS.id,
             command: DebugCommands.REMOVE_ALL_WATCH_EXPRESSIONS.id,
             icon: codicon('close-all'),
-            tooltip: 'Remove All Expressions',
+            tooltip: DebugCommands.REMOVE_ALL_WATCH_EXPRESSIONS.label,
             priority: 2
         });
     }
@@ -1125,8 +1160,8 @@ export class DebugFrontendApplicationContribution extends AbstractViewContributi
     protected async openSession(
         session: DebugSession,
         options?: {
-            debugViewLocation?: DebugViewLocation
-            reveal?: boolean
+            debugViewLocation?: DebugViewLocation;
+            reveal?: boolean;
         }
     ): Promise<DebugWidget | DebugSessionWidget> {
         const { debugViewLocation, reveal } = {

package/src/browser/debug-preferences.ts

@@ -14,6 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
+import { nls } from '@theia/core/lib/common/nls';
 import { PreferenceSchema, PreferenceProxy, PreferenceService, createPreferenceProxy, PreferenceContribution } from '@theia/core/lib/browser/preferences';
 import { interfaces } from '@theia/core/shared/inversify';
 
@@ -23,32 +24,47 @@ export const debugPreferencesSchema: PreferenceSchema = {
         'debug.trace': {
             type: 'boolean',
             default: false,
-            description: 'Enable/disable tracing communications with debug adapters'
+            description: nls.localize('theia/debug/toggleTracing', 'Enable/disable tracing communications with debug adapters')
         },
         'debug.debugViewLocation': {
             enum: ['default', 'left', 'right', 'bottom'],
             default: 'default',
-            description: 'Controls the location of the debug view.'
+            description: nls.localize('theia/debug/debugViewLocation', 'Controls the location of the debug view.')
         },
         'debug.openDebug': {
             enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart', 'openOnDebugBreak'],
             default: 'openOnSessionStart',
-            description: 'Controls when the debug view should open.'
+            description: nls.localizeByDefault('Controls when the debug view should open.')
         },
         'debug.internalConsoleOptions': {
             enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart'],
             default: 'openOnFirstSessionStart',
-            description: 'Controls when the internal debug console should open.'
+            description: nls.localizeByDefault('Controls when the internal debug console should open.')
         },
         'debug.inlineValues': {
             type: 'boolean',
             default: false,
-            description: 'Show variable values inline in editor while debugging.'
+            description: nls.localizeByDefault('Show variable values inline in editor while debugging.')
         },
         'debug.showInStatusBar': {
             enum: ['never', 'always', 'onFirstSessionStart'],
-            description: 'Controls when the debug status bar should be visible.',
+            enumDescriptions: [
+                nls.localizeByDefault('Never show debug in status bar'),
+                nls.localizeByDefault('Always show debug in status bar'),
+                nls.localizeByDefault('Show debug in status bar only after debug was started for the first time')
+            ],
+            description: nls.localizeByDefault('Controls when the debug status bar should be visible.'),
             default: 'onFirstSessionStart'
+        },
+        'debug.confirmOnExit': {
+            description: 'Controls whether to confirm when the window closes if there are active debug sessions.',
+            type: 'string',
+            enum: ['never', 'always'],
+            enumDescriptions: [
+                'Never confirm.',
+                'Always confirm if there are debug sessions.',
+            ],
+            default: 'never'
         }
     }
 };
@@ -60,6 +76,7 @@ export class DebugConfiguration {
     'debug.internalConsoleOptions': 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart';
     'debug.inlineValues': boolean;
     'debug.showInStatusBar': 'never' | 'always' | 'onFirstSessionStart';
+    'debug.confirmOnExit': 'never' | 'always';
 }
 
 export const DebugPreferenceContribution = Symbol('DebugPreferenceContribution');

package/src/browser/debug-prefix-configuration.ts

@@ -61,11 +61,11 @@ export class DebugPrefixConfiguration implements CommandContribution, CommandHan
 
     readonly statusBarId = 'select-run-debug-statusbar-item';
 
-    private readonly command: Command = {
+    private readonly command = Command.toDefaultLocalizedCommand({
         id: 'select.debug.configuration',
-        category: 'Debug',
+        category: DebugCommands.DEBUG_CATEGORY,
         label: 'Select and Start Debugging'
-    };
+    });
 
     @postConstruct()
     protected initialize(): void {
@@ -135,7 +135,7 @@ export class DebugPrefixConfiguration implements CommandContribution, CommandHan
             for (const configuration of dynamicConfigurations) {
                 items.push({
                     label: configuration.name,
-                    execute: () => this.runConfiguration({configuration})
+                    execute: () => this.runConfiguration({ configuration })
                 });
             }
         }