@codingame/monaco-vscode-debug-service-override 8.0.4 → 9.0.0

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

@@ -290,7 +290,7 @@ let DebugSession = class DebugSession {
     async launchOrAttach(config) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'launch or attach')
+                localize(5729, "No debugger available, can not send '{0}'", 'launch or attach')
             )));
         }
         if (this.parentSession && this.parentSession.state === State.Inactive) {
@@ -346,7 +346,7 @@ let DebugSession = class DebugSession {
     }
     async restart() {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'restart'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'restart'))));
         }
         this.cancelAllRequests();
         if (this._options.lifecycleManagedByParent && this.parentSession) {
@@ -358,7 +358,7 @@ let DebugSession = class DebugSession {
     }
     async sendBreakpoints(modelUri, breakpointsToSend, sourceModified) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'breakpoints'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'breakpoints'))));
         }
         if (!this.raw.readyForBreakpoints) {
             return Promise.resolve(undefined);
@@ -387,7 +387,7 @@ let DebugSession = class DebugSession {
     async sendFunctionBreakpoints(fbpts) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'function breakpoints')
+                localize(5729, "No debugger available, can not send '{0}'", 'function breakpoints')
             )));
         }
         if (this.raw.readyForBreakpoints) {
@@ -404,7 +404,7 @@ let DebugSession = class DebugSession {
     async sendExceptionBreakpoints(exbpts) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'exception breakpoints')
+                localize(5729, "No debugger available, can not send '{0}'", 'exception breakpoints')
             )));
         }
         if (this.raw.readyForBreakpoints) {
@@ -429,7 +429,7 @@ let DebugSession = class DebugSession {
     }
     dataBytesBreakpointInfo(address, bytes) {
         if (this.raw?.capabilities.supportsDataBreakpointBytes === false) {
-            throw ( (new Error(localize(5790, "Session does not support breakpoints with bytes"))));
+            throw ( (new Error(localize(5730, "Session does not support breakpoints with bytes"))));
         }
         return this._dataBreakpointInfo({ name: address, bytes, asAddress: true });
     }
@@ -439,11 +439,11 @@ let DebugSession = class DebugSession {
     async _dataBreakpointInfo(args) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'data breakpoints info')
+                localize(5729, "No debugger available, can not send '{0}'", 'data breakpoints info')
             )));
         }
         if (!this.raw.readyForBreakpoints) {
-            throw ( (new Error(localize(5791, "Session is not ready for breakpoints"))));
+            throw ( (new Error(localize(5731, "Session is not ready for breakpoints"))));
         }
         const response = await this.raw.dataBreakpointInfo(args);
         return response?.body;
@@ -451,7 +451,7 @@ let DebugSession = class DebugSession {
     async sendDataBreakpoints(dataBreakpoints) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'data breakpoints')
+                localize(5729, "No debugger available, can not send '{0}'", 'data breakpoints')
             )));
         }
         if (this.raw.readyForBreakpoints) {
@@ -483,7 +483,7 @@ let DebugSession = class DebugSession {
     async sendInstructionBreakpoints(instructionBreakpoints) {
         if (!this.raw) {
             throw ( (new Error(localize(
-                5789,
+                5729,
                 "No debugger available, can not send '{0}'",
                 'instruction breakpoints'
             ))));
@@ -502,7 +502,7 @@ let DebugSession = class DebugSession {
     async breakpointsLocations(uri, lineNumber) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'breakpoints locations')
+                localize(5729, "No debugger available, can not send '{0}'", 'breakpoints locations')
             )));
         }
         const source = this.getRawSource(uri);
@@ -518,13 +518,13 @@ let DebugSession = class DebugSession {
     }
     customRequest(request, args) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", request))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", request))));
         }
         return this.raw.custom(request, args);
     }
     stackTrace(threadId, startFrame, levels, token) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'stackTrace'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'stackTrace'))));
         }
         const sessionToken = this.getNewCancellationToken(threadId, token);
         return this.raw.stackTrace({ threadId, startFrame, levels }, sessionToken);
@@ -532,7 +532,7 @@ let DebugSession = class DebugSession {
     async exceptionInfo(threadId) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'exceptionInfo')
+                localize(5729, "No debugger available, can not send '{0}'", 'exceptionInfo')
             )));
         }
         const response = await this.raw.exceptionInfo({ threadId });
@@ -548,21 +548,21 @@ let DebugSession = class DebugSession {
     }
     scopes(frameId, threadId) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'scopes'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'scopes'))));
         }
         const token = this.getNewCancellationToken(threadId);
         return this.raw.scopes({ frameId }, token);
     }
     variables(variablesReference, threadId, filter, start, count) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'variables'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'variables'))));
         }
         const token = threadId ? this.getNewCancellationToken(threadId) : undefined;
         return this.raw.variables({ variablesReference, filter, start, count }, token);
     }
     evaluate(expression, frameId, context, location) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'evaluate'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'evaluate'))));
         }
         return this.raw.evaluate({ expression, frameId, context, line: location?.line, column: location?.column, source: location?.source });
     }
@@ -570,7 +570,7 @@ let DebugSession = class DebugSession {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'restartFrame')
+                localize(5729, "No debugger available, can not send '{0}'", 'restartFrame')
             )));
         }
         await this.raw.restartFrame({ frameId }, threadId);
@@ -584,7 +584,7 @@ let DebugSession = class DebugSession {
     async next(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'next'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'next'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.next({ threadId, granularity });
@@ -592,7 +592,7 @@ let DebugSession = class DebugSession {
     async stepIn(threadId, targetId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'stepIn'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'stepIn'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepIn({ threadId, targetId, granularity });
@@ -600,7 +600,7 @@ let DebugSession = class DebugSession {
     async stepOut(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'stepOut'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'stepOut'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepOut({ threadId, granularity });
@@ -608,7 +608,7 @@ let DebugSession = class DebugSession {
     async stepBack(threadId, granularity) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'stepBack'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'stepBack'))));
         }
         this.setLastSteppingGranularity(threadId, granularity);
         await this.raw.stepBack({ threadId, granularity });
@@ -616,7 +616,7 @@ let DebugSession = class DebugSession {
     async continue(threadId) {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'continue'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'continue'))));
         }
         await this.raw.continue({ threadId });
     }
@@ -624,54 +624,54 @@ let DebugSession = class DebugSession {
         await this.waitForTriggeredBreakpoints();
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'reverse continue')
+                localize(5729, "No debugger available, can not send '{0}'", 'reverse continue')
             )));
         }
         await this.raw.reverseContinue({ threadId });
     }
     async pause(threadId) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'pause'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'pause'))));
         }
         await this.raw.pause({ threadId });
     }
     async terminateThreads(threadIds) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'terminateThreads')
+                localize(5729, "No debugger available, can not send '{0}'", 'terminateThreads')
             )));
         }
         await this.raw.terminateThreads({ threadIds });
     }
     setVariable(variablesReference, name, value) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'setVariable'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'setVariable'))));
         }
         return this.raw.setVariable({ variablesReference, name, value });
     }
     setExpression(frameId, expression, value) {
         if (!this.raw) {
             throw ( (new Error(
-                localize(5789, "No debugger available, can not send '{0}'", 'setExpression')
+                localize(5729, "No debugger available, can not send '{0}'", 'setExpression')
             )));
         }
         return this.raw.setExpression({ expression, value, frameId });
     }
     gotoTargets(source, line, column) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'gotoTargets'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'gotoTargets'))));
         }
         return this.raw.gotoTargets({ source, line, column });
     }
     goto(threadId, targetId) {
         if (!this.raw) {
-            throw ( (new Error(localize(5789, "No debugger available, can not send '{0}'", 'goto'))));
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'goto'))));
         }
         return this.raw.goto({ threadId, targetId });
     }
     loadSource(resource) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'loadSource'))))));
+            return Promise.reject(( (new Error(( localize(5729, "No debugger available, can not send '{0}'", 'loadSource'))))));
         }
         const source = this.getSourceForUri(resource);
         let rawSource;
@@ -686,7 +686,7 @@ let DebugSession = class DebugSession {
     }
     async getLoadedSources() {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'getLoadedSources'))))));
+            return Promise.reject(( (new Error(( localize(5729, "No debugger available, can not send '{0}'", 'getLoadedSources'))))));
         }
         const response = await this.raw.loadedSources({});
         if (response?.body && response.body.sources) {
@@ -700,7 +700,7 @@ let DebugSession = class DebugSession {
     }
     async completions(frameId, threadId, text, position, overwriteBefore, token) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'completions'))))));
+            return Promise.reject(( (new Error(( localize(5729, "No debugger available, can not send '{0}'", 'completions'))))));
         }
         const sessionCancelationToken = this.getNewCancellationToken(threadId, token);
         return this.raw.completions({
@@ -712,36 +712,47 @@ let DebugSession = class DebugSession {
     }
     async stepInTargets(frameId) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'stepInTargets'))))));
+            return Promise.reject(( (new Error(( localize(5729, "No debugger available, can not send '{0}'", 'stepInTargets'))))));
         }
         const response = await this.raw.stepInTargets({ frameId });
         return response?.body.targets;
     }
     async cancel(progressId) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'cancel'))))));
+            return Promise.reject(( (new Error(( localize(5729, "No debugger available, can not send '{0}'", 'cancel'))))));
         }
         return this.raw.cancel({ progressId });
     }
     async disassemble(memoryReference, offset, instructionOffset, instructionCount) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'disassemble'))))));
+            return Promise.reject(( (new Error(( localize(5729, "No debugger available, can not send '{0}'", 'disassemble'))))));
         }
         const response = await this.raw.disassemble({ memoryReference, offset, instructionOffset, instructionCount, resolveSymbols: true });
         return response?.body?.instructions;
     }
     readMemory(memoryReference, offset, count) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'readMemory'))))));
+            return Promise.reject(( (new Error(( localize(5729, "No debugger available, can not send '{0}'", 'readMemory'))))));
         }
         return this.raw.readMemory({ count, memoryReference, offset });
     }
     writeMemory(memoryReference, offset, data, allowPartial) {
         if (!this.raw) {
-            return Promise.reject(( (new Error(( localize(5789, "No debugger available, can not send '{0}'", 'disassemble'))))));
+            return Promise.reject(( (new Error(( localize(5729, "No debugger available, can not send '{0}'", 'disassemble'))))));
         }
         return this.raw.writeMemory({ memoryReference, offset, allowPartial, data });
     }
+    async resolveLocationReference(locationReference) {
+        if (!this.raw) {
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'locations'))));
+        }
+        const location = await this.raw.locations({ locationReference });
+        if (!location?.body) {
+            throw ( (new Error(localize(5729, "No debugger available, can not send '{0}'", 'locations'))));
+        }
+        const source = this.getSource(location.body.source);
+        return { column: 1, ...location.body, source };
+    }
     getThread(threadId) {
         return this.threads.get(threadId);
     }
@@ -849,8 +860,8 @@ let DebugSession = class DebugSession {
         }
         this.rawListeners.add(this.raw.onDidInitialize(async () => {
             status(this.configuration.noDebug
-                ? ( localize(5792, "Started running without debugging."))
-                : ( localize(5793, "Debugging started.")));
+                ? ( localize(5732, "Started running without debugging."))
+                : ( localize(5733, "Debugging started.")));
             const sendConfigurationDone = async () => {
                 if (this.raw && this.raw.capabilities.supportsConfigurationDoneRequest) {
                     try {
@@ -897,7 +908,7 @@ let DebugSession = class DebugSession {
             }
         }));
         this.rawListeners.add(this.raw.onDidTerminateDebugee(async (event) => {
-            status(( localize(5794, "Debugging stopped.")));
+            status(( localize(5734, "Debugging stopped.")));
             if (event.body && event.body.restart) {
                 await this.debugService.restartSession(this, event.body.restart);
             }
@@ -1121,7 +1132,7 @@ let DebugSession = class DebugSession {
                     return;
                 }
                 const focusedStackFrame = this.debugService.getViewModel().focusedStackFrame;
-                if (!focusedStackFrame || !isFrameDeemphasized(focusedStackFrame)) {
+                if (!focusedStackFrame || isFrameDeemphasized(focusedStackFrame)) {
                     focus();
                 }
             }

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

@@ -49,10 +49,10 @@ let DebugStatusContribution = class DebugStatusContribution {
             text = (manager.getLaunches().length > 1 ? `${name} (${manager.selectedConfiguration.launch.name})` : name);
         }
         return {
-            name: ( localize(6038, "Debug")),
+            name: ( localize(5981, "Debug")),
             text: '$(debug-alt-small) ' + text,
-            ariaLabel: ( localize(6039, "Debug: {0}", text)),
-            tooltip: ( localize(6040, "Select and start debug configuration")),
+            ariaLabel: ( localize(5982, "Debug: {0}", text)),
+            tooltip: ( localize(5983, "Select and start debug configuration")),
             command: 'workbench.action.debug.selectandstart'
         };
     }