@codingame/monaco-vscode-debug-service-override 1.83.2 → 1.83.3

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

@@ -7,7 +7,7 @@ const debuggersExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'debuggers',
     defaultExtensionKind: ['workspace'],
     jsonSchema: {
-        description: ( nls.localize('vscode.extension.contributes.debuggers', 'Contributes debug adapters.')),
+        description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers', 'Contributes debug adapters.'),
         type: 'array',
         defaultSnippets: [{ body: [{ type: '' }] }],
         items: {
@@ -16,160 +16,100 @@ const debuggersExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
             defaultSnippets: [{ body: { type: '', program: '', runtime: '' } }],
             properties: {
                 type: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.type',
-                        "Unique identifier for this debug adapter."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.type', "Unique identifier for this debug adapter."),
                     type: 'string'
                 },
                 label: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.label',
-                        "Display name for this debug adapter."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.label', "Display name for this debug adapter."),
                     type: 'string'
                 },
                 program: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.program',
-                        "Path to the debug adapter program. Path is either absolute or relative to the extension folder."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.program', "Path to the debug adapter program. Path is either absolute or relative to the extension folder."),
                     type: 'string'
                 },
                 args: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.args',
-                        "Optional arguments to pass to the adapter."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.args', "Optional arguments to pass to the adapter."),
                     type: 'array'
                 },
                 runtime: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.runtime',
-                        "Optional runtime in case the program attribute is not an executable but requires a runtime."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.runtime', "Optional runtime in case the program attribute is not an executable but requires a runtime."),
                     type: 'string'
                 },
                 runtimeArgs: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.runtimeArgs',
-                        "Optional runtime arguments."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.runtimeArgs', "Optional runtime arguments."),
                     type: 'array'
                 },
                 variables: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.variables',
-                        "Mapping from interactive variables (e.g. ${action.pickProcess}) in `launch.json` to a command."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.variables', "Mapping from interactive variables (e.g. ${action.pickProcess}) in `launch.json` to a command."),
                     type: 'object'
                 },
                 initialConfigurations: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.initialConfigurations',
-                        "Configurations for generating the initial \'launch.json\'."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.initialConfigurations', "Configurations for generating the initial \'launch.json\'."),
                     type: ['array', 'string'],
                 },
                 languages: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.languages',
-                        "List of languages for which the debug extension could be considered the \"default debugger\"."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.languages', "List of languages for which the debug extension could be considered the \"default debugger\"."),
                     type: 'array'
                 },
                 configurationSnippets: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.configurationSnippets',
-                        "Snippets for adding new configurations in \'launch.json\'."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.configurationSnippets', "Snippets for adding new configurations in \'launch.json\'."),
                     type: 'array'
                 },
                 configurationAttributes: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.configurationAttributes',
-                        "JSON schema configurations for validating \'launch.json\'."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.configurationAttributes', "JSON schema configurations for validating \'launch.json\'."),
                     type: 'object'
                 },
                 when: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.when',
-                        "Condition which must be true to enable this type of debugger. Consider using 'shellExecutionSupported', 'virtualWorkspace', 'resourceScheme' or an extension-defined context key as appropriate for this."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.when', "Condition which must be true to enable this type of debugger. Consider using 'shellExecutionSupported', 'virtualWorkspace', 'resourceScheme' or an extension-defined context key as appropriate for this."),
                     type: 'string',
                     default: ''
                 },
                 hiddenWhen: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.hiddenWhen',
-                        "When this condition is true, this debugger type is hidden from the debugger list, but is still enabled."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.hiddenWhen', "When this condition is true, this debugger type is hidden from the debugger list, but is still enabled."),
                     type: 'string',
                     default: ''
                 },
                 deprecated: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.deprecated',
-                        "Optional message to mark this debug type as being deprecated."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.deprecated', "Optional message to mark this debug type as being deprecated."),
                     type: 'string',
                     default: ''
                 },
                 windows: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.windows',
-                        "Windows specific settings."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.windows', "Windows specific settings."),
                     type: 'object',
                     properties: {
                         runtime: {
-                            description: ( nls.localize(
-                                'vscode.extension.contributes.debuggers.windows.runtime',
-                                "Runtime used for Windows."
-                            )),
+                            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.windows.runtime', "Runtime used for Windows."),
                             type: 'string'
                         }
                     }
                 },
                 osx: {
-                    description: ( nls.localize('vscode.extension.contributes.debuggers.osx', "macOS specific settings.")),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.osx', "macOS specific settings."),
                     type: 'object',
                     properties: {
                         runtime: {
-                            description: ( nls.localize(
-                                'vscode.extension.contributes.debuggers.osx.runtime',
-                                "Runtime used for macOS."
-                            )),
+                            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.osx.runtime', "Runtime used for macOS."),
                             type: 'string'
                         }
                     }
                 },
                 linux: {
-                    description: ( nls.localize('vscode.extension.contributes.debuggers.linux', "Linux specific settings.")),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.linux', "Linux specific settings."),
                     type: 'object',
                     properties: {
                         runtime: {
-                            description: ( nls.localize(
-                                'vscode.extension.contributes.debuggers.linux.runtime',
-                                "Runtime used for Linux."
-                            )),
+                            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.linux.runtime', "Runtime used for Linux."),
                             type: 'string'
                         }
                     }
                 },
                 strings: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.debuggers.strings',
-                        "UI strings contributed by this debug adapter."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.strings', "UI strings contributed by this debug adapter."),
                     type: 'object',
                     properties: {
                         unverifiedBreakpoints: {
-                            description: ( nls.localize(
-                                'vscode.extension.contributes.debuggers.strings.unverifiedBreakpoints',
-                                "When there are unverified breakpoints in a language supported by this debug adapter, this message will appear on the breakpoint hover and in the breakpoints view. Markdown and command links are supported."
-                            )),
+                            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.debuggers.strings.unverifiedBreakpoints', "When there are unverified breakpoints in a language supported by this debug adapter, this message will appear on the breakpoint hover and in the breakpoints view. Markdown and command links are supported."),
                             type: 'string'
                         }
                     }
@@ -181,7 +121,7 @@ const debuggersExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
 const breakpointsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'breakpoints',
     jsonSchema: {
-        description: ( nls.localize('vscode.extension.contributes.breakpoints', 'Contributes breakpoints.')),
+        description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.breakpoints', 'Contributes breakpoints.'),
         type: 'array',
         defaultSnippets: [{ body: [{ language: '' }] }],
         items: {
@@ -190,17 +130,11 @@ const breakpointsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
             defaultSnippets: [{ body: { language: '' } }],
             properties: {
                 language: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.breakpoints.language',
-                        "Allow breakpoints for this language."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.breakpoints.language', "Allow breakpoints for this language."),
                     type: 'string'
                 },
                 when: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.breakpoints.when',
-                        "Condition which must be true to enable breakpoints in this language. Consider matching this to the debugger when clause as appropriate."
-                    )),
+                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'vscode.extension.contributes.breakpoints.when', "Condition which must be true to enable breakpoints in this language. Consider matching this to the debugger when clause as appropriate."),
                     type: 'string',
                     default: ''
                 }
@@ -210,34 +144,22 @@ const breakpointsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
 }));
 const presentationSchema = {
     type: 'object',
-    description: ( nls.localize(
-        'presentation',
-        "Presentation options on how to show this configuration in the debug configuration dropdown and the command palette."
-    )),
+    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'presentation', "Presentation options on how to show this configuration in the debug configuration dropdown and the command palette."),
     properties: {
         hidden: {
             type: 'boolean',
             default: false,
-            description: ( nls.localize(
-                'presentation.hidden',
-                "Controls if this configuration should be shown in the configuration dropdown and the command palette."
-            ))
+            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'presentation.hidden', "Controls if this configuration should be shown in the configuration dropdown and the command palette.")
         },
         group: {
             type: 'string',
             default: '',
-            description: ( nls.localize(
-                'presentation.group',
-                "Group that this configuration belongs to. Used for grouping and sorting in the configuration dropdown and the command palette."
-            ))
+            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'presentation.group', "Group that this configuration belongs to. Used for grouping and sorting in the configuration dropdown and the command palette.")
         },
         order: {
             type: 'number',
             default: 1,
-            description: ( nls.localize(
-                'presentation.order',
-                "Order of this configuration within a group. Used for grouping and sorting in the configuration dropdown and the command palette."
-            ))
+            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'presentation.order', "Order of this configuration within a group. Used for grouping and sorting in the configuration dropdown and the command palette.")
         }
     },
     default: {
@@ -250,7 +172,7 @@ const defaultCompound = { name: 'Compound', configurations: [] };
 const launchSchema = {
     id: launchSchemaId,
     type: 'object',
-    title: ( nls.localize('app.launch.json.title', "Launch")),
+    title: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'app.launch.json.title', "Launch"),
     allowTrailingCommas: true,
     allowComments: true,
     required: [],
@@ -258,15 +180,12 @@ const launchSchema = {
     properties: {
         version: {
             type: 'string',
-            description: ( nls.localize('app.launch.json.version', "Version of this file format.")),
+            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'app.launch.json.version', "Version of this file format."),
             default: '0.2.0'
         },
         configurations: {
             type: 'array',
-            description: ( nls.localize(
-                'app.launch.json.configurations',
-                "List of configurations. Add new configurations or edit existing ones by using IntelliSense."
-            )),
+            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'app.launch.json.configurations', "List of configurations. Add new configurations or edit existing ones by using IntelliSense."),
             items: {
                 defaultSnippets: [],
                 'type': 'object',
@@ -275,20 +194,14 @@ const launchSchema = {
         },
         compounds: {
             type: 'array',
-            description: ( nls.localize(
-                'app.launch.json.compounds',
-                "List of compounds. Each compound references multiple configurations which will get launched together."
-            )),
+            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'app.launch.json.compounds', "List of compounds. Each compound references multiple configurations which will get launched together."),
             items: {
                 type: 'object',
                 required: ['name', 'configurations'],
                 properties: {
                     name: {
                         type: 'string',
-                        description: ( nls.localize(
-                            'app.launch.json.compound.name',
-                            "Name of compound. Appears in the launch configuration drop down menu."
-                        ))
+                        description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'app.launch.json.compound.name', "Name of compound. Appears in the launch configuration drop down menu.")
                     },
                     presentation: presentationSchema,
                     configurations: {
@@ -297,48 +210,33 @@ const launchSchema = {
                         items: {
                             oneOf: [{
                                     enum: [],
-                                    description: ( nls.localize('useUniqueNames', "Please use unique configuration names."))
+                                    description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'useUniqueNames', "Please use unique configuration names.")
                                 }, {
                                     type: 'object',
                                     required: ['name'],
                                     properties: {
                                         name: {
                                             enum: [],
-                                            description: ( nls.localize(
-                                                'app.launch.json.compound.name',
-                                                "Name of compound. Appears in the launch configuration drop down menu."
-                                            ))
+                                            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'app.launch.json.compound.name', "Name of compound. Appears in the launch configuration drop down menu.")
                                         },
                                         folder: {
                                             enum: [],
-                                            description: ( nls.localize(
-                                                'app.launch.json.compound.folder',
-                                                "Name of folder in which the compound is located."
-                                            ))
+                                            description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'app.launch.json.compound.folder', "Name of folder in which the compound is located.")
                                         }
                                     }
                                 }]
                         },
-                        description: ( nls.localize(
-                            'app.launch.json.compounds.configurations',
-                            "Names of configurations that will be started as part of this compound."
-                        ))
+                        description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'app.launch.json.compounds.configurations', "Names of configurations that will be started as part of this compound.")
                     },
                     stopAll: {
                         type: 'boolean',
                         default: false,
-                        description: ( nls.localize(
-                            'app.launch.json.compound.stopAll',
-                            "Controls whether manually terminating one session will stop all of the compound sessions."
-                        ))
+                        description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'app.launch.json.compound.stopAll', "Controls whether manually terminating one session will stop all of the compound sessions.")
                     },
                     preLaunchTask: {
                         type: 'string',
                         default: '',
-                        description: ( nls.localize(
-                            'compoundPrelaunchTask',
-                            "Task to run before any of the compound configurations start."
-                        ))
+                        description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSchemas', 'compoundPrelaunchTask', "Task to run before any of the compound configurations start.")
                     }
                 },
                 default: defaultCompound

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

@@ -7,7 +7,7 @@ import { SIDE_GROUP, ACTIVE_GROUP } from 'vscode/vscode/vs/workbench/services/ed
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { isUri } from 'vscode/vscode/vs/workbench/contrib/debug/common/debugUtils';
 
-const UNKNOWN_SOURCE_LABEL = ( nls.localize('unknownSource', "Unknown Source"));
+const UNKNOWN_SOURCE_LABEL = nls.localizeWithPath('vs/workbench/contrib/debug/common/debugSource', 'unknownSource', "Unknown Source");
 class Source {
     constructor(raw_, sessionId, uriIdentityService, logService) {
         let path;

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

@@ -76,7 +76,7 @@ let Debugger = class Debugger {
         if (da) {
             return Promise.resolve(da);
         }
-        throw new Error(nls.localize('cannot.find.da', "Cannot find debug adapter for type '{0}'.", this.type));
+        throw new Error(nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'cannot.find.da', "Cannot find debug adapter for type '{0}'.", this.type));
     }
     async substituteVariables(folder, config) {
         const substitutedConfig = await this.adapterManager.substituteVariables(this.type, folder, config);
@@ -134,19 +134,9 @@ let Debugger = class Debugger {
         }
         const eol = this.resourcePropertiesService.getEOL(( URI.from({ scheme: Schemas.untitled, path: '1' }))) === '\r\n' ? '\r\n' : '\n';
         const configs = ( JSON.stringify(initialConfigurations, null, '\t').split('\n').map(line => '\t' + line)).join(eol).trim();
-        const comment1 = ( nls.localize(
-            'launch.config.comment1',
-            "Use IntelliSense to learn about possible attributes."
-        ));
-        const comment2 = ( nls.localize(
-            'launch.config.comment2',
-            "Hover to view descriptions of existing attributes."
-        ));
-        const comment3 = ( nls.localize(
-            'launch.config.comment3',
-            "For more information, visit: {0}",
-            'https://go.microsoft.com/fwlink/?linkid=830387'
-        ));
+        const comment1 = nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'launch.config.comment1', "Use IntelliSense to learn about possible attributes.");
+        const comment2 = nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'launch.config.comment2', "Hover to view descriptions of existing attributes.");
+        const comment3 = nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'launch.config.comment3', "For more information, visit: {0}", 'https://go.microsoft.com/fwlink/?linkid=830387');
         let content = [
             '{',
             `\t// ${comment1}`,
@@ -196,25 +186,16 @@ let Debugger = class Debugger {
             properties['type'] = {
                 enum: [this.type],
                 enumDescriptions: [this.label],
-                description: ( nls.localize('debugType', "Type of configuration.")),
+                description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'debugType', "Type of configuration."),
                 pattern: '^(?!node2)',
                 deprecationMessage: this.debuggerContribution.deprecated || (this.enabled ? undefined : debuggerDisabledMessage(this.type)),
                 doNotSuggest: !!this.debuggerContribution.deprecated,
-                errorMessage: ( nls.localize(
-                    'debugTypeNotRecognised',
-                    "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."
-                )),
-                patternErrorMessage: ( nls.localize(
-                    'node2NotSupported',
-                    "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\"."
-                ))
+                errorMessage: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'debugTypeNotRecognised', "The debug type is not recognized. Make sure that you have a corresponding debug extension installed and that it is enabled."),
+                patternErrorMessage: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'node2NotSupported', "\"node2\" is no longer supported, use \"node\" instead and set the \"protocol\" attribute to \"inspector\".")
             };
             properties['request'] = {
                 enum: [request],
-                description: ( nls.localize(
-                    'debugRequest',
-                    "Request type of configuration. Can be \"launch\" or \"attach\"."
-                )),
+                description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'debugRequest', "Request type of configuration. Can be \"launch\" or \"attach\"."),
             };
             for (const prop in definitions['common'].properties) {
                 properties[prop] = {
@@ -236,21 +217,15 @@ let Debugger = class Debugger {
                 ...{
                     windows: {
                         $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( nls.localize(
-                            'debugWindowsConfiguration',
-                            "Windows specific launch configuration attributes."
-                        )),
+                        description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'debugWindowsConfiguration', "Windows specific launch configuration attributes."),
                     },
                     osx: {
                         $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( nls.localize('debugOSXConfiguration', "OS X specific launch configuration attributes.")),
+                        description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'debugOSXConfiguration', "OS X specific launch configuration attributes."),
                     },
                     linux: {
                         $ref: `#/definitions/${platformSpecificDefinitionId}`,
-                        description: ( nls.localize(
-                            'debugLinuxConfiguration',
-                            "Linux specific launch configuration attributes."
-                        )),
+                        description: nls.localizeWithPath('vs/workbench/contrib/debug/common/debugger', 'debugLinuxConfiguration', "Linux specific launch configuration attributes."),
                     }
                 }
             };

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

@@ -1,5 +1,5 @@
 import { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 
 class DisassemblyViewInput extends EditorInput {
     constructor() {
@@ -17,7 +17,7 @@ class DisassemblyViewInput extends EditorInput {
         return DisassemblyViewInput._instance;
     }
     getName() {
-        return ( localize('disassemblyInputName', "Disassembly"));
+        return localizeWithPath('vs/workbench/contrib/debug/common/disassemblyViewInput', 'disassemblyInputName', "Disassembly");
     }
     matches(other) {
         return other instanceof DisassemblyViewInput;

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

@@ -22,7 +22,7 @@ async function showLoadedScriptMenu(accessor) {
     const quickPick = quickInputService.createQuickPick();
     localDisposableStore.add(quickPick);
     quickPick.matchOnLabel = quickPick.matchOnDescription = quickPick.matchOnDetail = quickPick.sortByLabel = false;
-    quickPick.placeholder = ( nls.localize('moveFocusedView.selectView', "Search loaded scripts by name"));
+    quickPick.placeholder = nls.localizeWithPath('vs/workbench/contrib/debug/common/loadedScriptsPicker', 'moveFocusedView.selectView', "Search loaded scripts by name");
     quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);
     localDisposableStore.add(quickPick.onDidChangeValue(async () => {
         quickPick.items = await _getPicks(quickPick.value, sessions, editorService, modelService, languageService, labelService);

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

@@ -219,7 +219,7 @@ class ReplModel {
         const clearAnsiIndex = output.lastIndexOf(clearAnsiSequence);
         if (clearAnsiIndex !== -1) {
             this.removeReplExpressions();
-            this.appendToRepl(session, { output: ( nls.localize('consoleCleared', "Console was cleared")), sev: Severity.Ignore });
+            this.appendToRepl(session, { output: nls.localizeWithPath('vs/workbench/contrib/debug/common/replModel', 'consoleCleared', "Console was cleared"), sev: Severity.Ignore });
             output = output.substring(clearAnsiIndex + clearAnsiSequence.length);
         }
         if (expression) {

package/vscode/src/vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService.js

@@ -165,7 +165,7 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
                     const commandId = (variableToCommandMap ? variableToCommandMap[name] : undefined) || name;
                     result = await this.commandService.executeCommand(commandId, configuration);
                     if (typeof result !== 'string' && !types.isUndefinedOrNull(result)) {
-                        throw new Error(nls.localize('commandVariable.noStringType', "Cannot substitute command variable '{0}' because command did not return a result of type string.", commandId));
+                        throw new Error(nls.localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'commandVariable.noStringType', "Cannot substitute command variable '{0}' because command did not return a result of type string.", commandId));
                     }
                     break;
                 }
@@ -213,17 +213,14 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
     }
     showUserInput(variable, inputInfos) {
         if (!inputInfos) {
-            return Promise.reject(( new Error(( nls.localize(
-                'inputVariable.noInputSection',
-                "Variable '{0}' must be defined in an '{1}' section of the debug or task configuration.",
-                variable,
-                'input'
-            )))));
+            return Promise.reject(( new Error(
+                nls.localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.noInputSection', "Variable '{0}' must be defined in an '{1}' section of the debug or task configuration.", variable, 'input')
+            )));
         }
         const info = inputInfos.filter(item => item.id === variable).pop();
         if (info) {
             const missingAttribute = (attrName) => {
-                throw new Error(nls.localize('inputVariable.missingAttribute', "Input variable '{0}' is of type '{1}' and must include '{2}'.", variable, info.type, attrName));
+                throw new Error(nls.localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.missingAttribute', "Input variable '{0}' is of type '{1}' and must include '{2}'.", variable, info.type, attrName));
             };
             switch (info.type) {
                 case 'promptString': {
@@ -264,7 +261,7 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
                             value: value
                         };
                         if (value === info.default) {
-                            item.description = ( nls.localize('inputVariable.defaultInputValue', "(Default)"));
+                            item.description = nls.localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.defaultInputValue', "(Default)");
                             picks.unshift(item);
                         }
                         else {
@@ -287,18 +284,16 @@ class BaseConfigurationResolverService extends AbstractVariableResolverService {
                         if (typeof result === 'string' || types.isUndefinedOrNull(result)) {
                             return result;
                         }
-                        throw new Error(nls.localize('inputVariable.command.noStringType', "Cannot substitute input variable '{0}' because command '{1}' did not return a result of type string.", variable, info.command));
+                        throw new Error(nls.localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.command.noStringType', "Cannot substitute input variable '{0}' because command '{1}' did not return a result of type string.", variable, info.command));
                     });
                 }
                 default:
-                    throw new Error(nls.localize('inputVariable.unknownType', "Input variable '{0}' can only be of type 'promptString', 'pickString', or 'command'.", variable));
+                    throw new Error(nls.localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.unknownType', "Input variable '{0}' can only be of type 'promptString', 'pickString', or 'command'.", variable));
             }
         }
-        return Promise.reject(( new Error(( nls.localize(
-            'inputVariable.undefinedVariable',
-            "Undefined input variable '{0}' encountered. Remove or define '{0}' to continue.",
-            variable
-        )))));
+        return Promise.reject(( new Error(
+            nls.localizeWithPath('vs/workbench/services/configurationResolver/browser/baseConfigurationResolverService', 'inputVariable.undefinedVariable', "Undefined input variable '{0}' encountered. Remove or define '{0}' to continue.", variable)
+        )));
     }
 }