🐛 use 32bit integers for threadid in protocol layer

src/client/debugger/Common/Contracts.ts

@@ -158,6 +158,7 @@ export interface IPythonThread {
     Process: IPythonProcess;
     Name: string;
     Id: number;
+    Int32Id: number;
     Frames: IPythonStackFrame[];
 }
 

src/client/debugger/Common/Utils.ts

@@ -38,13 +38,14 @@ export function validatePathSync(filePath: string): boolean {
     return exists;
 }
 
-export function CreatePythonThread(id: number, isWorker: boolean, process: IPythonProcess, name: string = ''): IPythonThread {
+export function CreatePythonThread(id: number, isWorker: boolean, process: IPythonProcess, name: string = '', int32Id: number = 0): IPythonThread {
     return {
         IsWorkerThread: isWorker,
         Process: process,
         Name: name,
         Id: id,
-        Frames: []
+        Frames: [],
+        Int32Id: int32Id
     };
 }
 

src/client/debugger/Main.ts

@@ -145,21 +145,21 @@ export class PythonDebugger extends LoggingDebugSession {
         this.stopDebugServer();
     }
     private onPythonThreadCreated(pyThread: IPythonThread) {
-        this.sendEvent(new ThreadEvent("started", pyThread.Id));
+        this.sendEvent(new ThreadEvent("started", pyThread.Int32Id));
     }
     private onStepCompleted(pyThread: IPythonThread) {
-        this.sendEvent(new StoppedEvent("step", pyThread.Id));
+        this.sendEvent(new StoppedEvent("step", pyThread.Int32Id));
     }
     private onPythonException(pyThread: IPythonThread, ex: IPythonException) {
         this.lastException = ex;
-        this.sendEvent(new StoppedEvent("exception", pyThread.Id, `${ex.TypeName}, ${ex.Description}`));
+        this.sendEvent(new StoppedEvent("exception", pyThread.Int32Id, `${ex.TypeName}, ${ex.Description}`));
         this.sendEvent(new OutputEvent(`${ex.TypeName}, ${ex.Description}\n`, "stderr"));
     }
     private onPythonThreadExited(pyThread: IPythonThread) {
-        this.sendEvent(new ThreadEvent("exited", pyThread.Id));
+        this.sendEvent(new ThreadEvent("exited", pyThread.Int32Id));
     }
     private onPythonProcessPaused(pyThread: IPythonThread) {
-        this.sendEvent(new StoppedEvent("user request", pyThread.Id));
+        this.sendEvent(new StoppedEvent("user request", pyThread.Int32Id));
     }
     private onPythonModuleLoaded(module: IPythonModule) {
     }
@@ -181,7 +181,7 @@ export class PythonDebugger extends LoggingDebugSession {
             // tslint:disable-next-line:no-non-null-assertion
             const thread = pyThread!;
             if (this.launchArgs && this.launchArgs.stopOnEntry === true) {
-                this.sendEvent(new StoppedEvent("entry", thread.Id));
+                this.sendEvent(new StoppedEvent("entry", thread.Int32Id));
             } else if (this.launchArgs && this.launchArgs.stopOnEntry === false) {
                 this.configurationDone.then(() => {
                     this.pythonProcess!.SendResumeThread(thread.Id);
@@ -320,7 +320,7 @@ export class PythonDebugger extends LoggingDebugSession {
     private onBreakpointHit(pyThread: IPythonThread, breakpointId: number) {
         // Break only if the breakpoint exists and it is enabled
         if (this.registeredBreakpoints.has(breakpointId) && this.registeredBreakpoints.get(breakpointId)!.Enabled === true) {
-            this.sendEvent(new StoppedEvent("breakpoint", pyThread.Id));
+            this.sendEvent(new StoppedEvent("breakpoint", pyThread.Int32Id));
         }
         else {
             this.pythonProcess!.SendResumeThread(pyThread.Id);
@@ -429,7 +429,7 @@ export class PythonDebugger extends LoggingDebugSession {
         const threads: Thread[] = [];
         if (this.pythonProcess) {
             this.pythonProcess!.Threads.forEach(t => {
-                threads.push(new Thread(t.Id, t.Name));
+                threads.push(new Thread(t.Int32Id, t.Name));
             });
         }
 
@@ -466,14 +466,13 @@ export class PythonDebugger extends LoggingDebugSession {
     }
     protected stackTraceRequest(response: DebugProtocol.StackTraceResponse, args: DebugProtocol.StackTraceArguments): void {
         this.debuggerLoaded.then(() => {
-            if (this.terminateEventSent || !this.pythonProcess || !this.pythonProcess!.Threads.has(args.threadId)) {
+            if (this.terminateEventSent || !this.pythonProcess || Array.from(this.pythonProcess!.Threads.values()).findIndex(t => t.Int32Id === args.threadId) === -1) {
                 response.body = {
                     stackFrames: []
                 };
                 return this.sendResponse(response);
             }
-
-            const pyThread = this.pythonProcess!.Threads.get(args.threadId)!;
+            const pyThread = Array.from(this.pythonProcess!.Threads.values()).find(t => t.Int32Id === args.threadId)!;
             let maxFrames = typeof args.levels === "number" && args.levels > 0 ? args.levels : pyThread.Frames.length - 1;
             maxFrames = maxFrames < pyThread.Frames.length ? maxFrames : pyThread.Frames.length;
 

src/client/debugger/PythonProcessCallbackHandler.ts

@@ -10,6 +10,7 @@ import { SocketStream } from "../common/net/socket/SocketStream";
 import { ExtractTryStatements } from "./Common/TryParser";
 import * as path from "path";
 import { IdDispenser } from '../common/idDispenser';
+import '../../client/common/extensions';
 
 export class PythonProcessCallbackHandler extends EventEmitter {
     private process: IPythonProcess;
@@ -113,7 +114,7 @@ export class PythonProcessCallbackHandler extends EventEmitter {
             return;
         }
 
-        let pyThread = utils.CreatePythonThread(threadId, this._createdFirstThread, this.process);
+        let pyThread = utils.CreatePythonThread(threadId, this._createdFirstThread, this.process, '', this.process.Threads.size + 1);
         this._createdFirstThread = true;
         this.process.Threads.set(threadId, pyThread);
         this.emit("threadCreated", pyThread);
@@ -220,7 +221,7 @@ export class PythonProcessCallbackHandler extends EventEmitter {
                 });
                 this.stream.WriteString("-");
             });
-        });
+        }).ignoreErrors();
     }
     private GetHandledExceptionRanges(fileName: string): Promise<{ startLine: number, endLine: number, expressions: string[] }[]> {
         return ExtractTryStatements(fileName).then(statements => {

src/test/debugger/misc.test.ts

@@ -17,6 +17,7 @@ use(chaiAsPromised);
 const debugFilesPath = path.join(__dirname, '..', '..', '..', 'src', 'test', 'pythonFiles', 'debugging');
 
 const DEBUG_ADAPTER = path.join(__dirname, '..', '..', 'client', 'debugger', 'Main.js');
+const MAX_SIGNED_INT32 = Math.pow(2, 31) - 1;
 
 // tslint:disable-next-line:max-func-body-length
 suite('Standard Debugging - Misc tests', () => {
@@ -103,6 +104,23 @@ suite('Standard Debugging - Misc tests', () => {
             debugClient.waitForEvent('terminated')
         ]);
     });
+    test('Ensure threadid is int32', async () => {
+        const threadIdPromise = debugClient.waitForEvent('thread');
+
+        await Promise.all([
+            debugClient.configurationSequence(),
+            debugClient.launch(buildLauncArgs('simplePrint.py', true)),
+            debugClient.waitForEvent('initialized'),
+            debugClient.waitForEvent('stopped')
+        ]);
+
+        const threadId = ((await threadIdPromise) as ThreadEvent).body.threadId;
+        expect(threadId).to.be.lessThan(MAX_SIGNED_INT32 + 1, 'ThreadId is not an integer');
+        await Promise.all([
+            debugClient.continueRequest({ threadId }),
+            debugClient.waitForEvent('terminated')
+        ]);
+    });
     test('Should break at print statement (line 3)', async () => {
         const launchArgs = buildLauncArgs('sample2.py', false);
         const breakpointLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 0, line: 3 };
@@ -372,6 +390,9 @@ suite('Standard Debugging - Misc tests', () => {
 
         const threads = await debugClient.threadsRequest();
         expect(threads.body.threads).of.lengthOf(2, 'incorrect number of threads');
+        for (const thread of threads.body.threads) {
+            expect(thread.id).to.be.lessThan(MAX_SIGNED_INT32 + 1, 'ThreadId is not an integer');
+        }
     });
     test('Test stack frames', async () => {
         await Promise.all([