Ensure debug adapter request/response sequence numbers tally

src/client/datascience/debugLocationTracker.ts

@@ -3,17 +3,19 @@
 'use strict';
 import { DebugAdapterTracker, Event, EventEmitter } from 'vscode';
 import { DebugProtocol } from 'vscode-debugprotocol';
+import { DebugStackTraceTracker } from './jupyter/debugStackTraceTracker';
 
 import { IDebugLocation } from './types';
 
 // When a python debugging session is active keep track of the current debug location
-export class DebugLocationTracker implements DebugAdapterTracker {
+export class DebugLocationTracker extends DebugStackTraceTracker implements DebugAdapterTracker {
     private waitingForStackTrace: boolean = false;
     private _debugLocation: IDebugLocation | undefined;
     private debugLocationUpdatedEvent: EventEmitter<void> = new EventEmitter<void>();
     private sessionEndedEmitter: EventEmitter<DebugLocationTracker> = new EventEmitter<DebugLocationTracker>();
 
     constructor(private _sessionId: string) {
+        super();
         this.DebugLocation = undefined;
     }
 
@@ -34,7 +36,8 @@ export class DebugLocationTracker implements DebugAdapterTracker {
     }
 
     // tslint:disable-next-line:no-any
-    public onDidSendMessage(message: DebugProtocol.ProtocolMessage) {
+    public onDidSendMessage(message: DebugProtocol.Response) {
+        super.onDidSendMessage(message);
         if (this.isStopEvent(message)) {
             // Some type of stop, wait to see our next stack trace to find our location
             this.waitingForStackTrace = true;
@@ -88,7 +91,10 @@ export class DebugLocationTracker implements DebugAdapterTracker {
             const responseMessage = message as DebugProtocol.Response;
             if (responseMessage.command === 'stackTrace') {
                 const messageBody = responseMessage.body;
-                if (messageBody.stackFrames.length > 0) {
+                if (
+                    messageBody.stackFrames.length > 0 &&
+                    this.stackFrameRequestSequenceNumber === responseMessage.request_seq
+                ) {
                     const lineNumber = messageBody.stackFrames[0].line;
                     const fileName = this.normalizeFilePath(messageBody.stackFrames[0].source.path);
                     const column = messageBody.stackFrames[0].column;

src/client/datascience/jupyter/debugStackTraceTracker.ts

@@ -0,0 +1,29 @@
+import { DebugProtocol } from 'vscode-debugprotocol';
+
+export class DebugStackTraceTracker {
+    protected topMostFrameId = 0;
+    protected stackFrameRequestSequenceNumber: number = -1; // Keep track of the sequence number
+
+    public onDidSendMessage(message: DebugProtocol.Response) {
+        if (
+            message.type === 'response' &&
+            message.command === 'stackTrace' &&
+            message.body.stackFrames[0] &&
+            message.request_seq === this.stackFrameRequestSequenceNumber
+        ) {
+            // This should be the top frame. We need to use this to compute the value of a variable
+            this.topMostFrameId = message.body.stackFrames[0].id;
+        }
+    }
+
+    public onWillReceiveMessage(message: DebugProtocol.Request) {
+        if (message.type === 'request' && message.command === 'stackTrace' && message.arguments.startFrame === 0) {
+            // VSCode sometimes sends multiple stackTrace requests. The true topmost frame is determined
+            // based on the response to a stackTrace request where the startFrame is 0 (i.e. this request
+            // retrieves all frames). Here, remember the sequence number of the outgoing request whose
+            // startFrame === 0, and update this.topMostFrameId only when we receive the response with a
+            // matching sequence number.
+            this.stackFrameRequestSequenceNumber = message.seq;
+        }
+    }
+}

src/client/datascience/jupyter/debuggerVariables.ts

@@ -18,22 +18,25 @@ import {
     IJupyterVariablesResponse,
     INotebook
 } from '../types';
+import { DebugStackTraceTracker } from './debugStackTraceTracker';
 
 const DataViewableTypes: Set<string> = new Set<string>(['DataFrame', 'list', 'dict', 'ndarray', 'Series']);
 const KnownExcludedVariables = new Set<string>(['In', 'Out', 'exit', 'quit']);
 
 @injectable()
-export class DebuggerVariables implements IConditionalJupyterVariables, DebugAdapterTracker {
+export class DebuggerVariables extends DebugStackTraceTracker
+    implements IConditionalJupyterVariables, DebugAdapterTracker {
     private refreshEventEmitter = new EventEmitter<void>();
     private lastKnownVariables: IJupyterVariable[] = [];
-    private topMostFrameId = 0;
     private importedIntoKernel = new Set<string>();
     private watchedNotebooks = new Map<string, Disposable[]>();
     private debuggingStarted = false;
     constructor(
         @inject(IJupyterDebugService) @named(Identifiers.MULTIPLEXING_DEBUGSERVICE) private debugService: IDebugService,
         @inject(IConfigurationService) private configService: IConfigurationService
-    ) {}
+    ) {
+        super();
+    }
 
     public get refreshRequired(): Event<void> {
         return this.refreshEventEmitter.event;
@@ -166,6 +169,7 @@ export class DebuggerVariables implements IConditionalJupyterVariables, DebugAda
 
     // tslint:disable-next-line: no-any
     public onDidSendMessage(message: any) {
+        super.onDidSendMessage(message);
         // When the initialize response comes back, indicate we have started.
         if (message.type === 'response' && message.command === 'initialize') {
             this.debuggingStarted = true;
@@ -174,9 +178,6 @@ export class DebuggerVariables implements IConditionalJupyterVariables, DebugAda
             // tslint:disable-next-line: no-suspicious-comment
             // TODO: Figure out what resource to use
             this.updateVariables(undefined, message as DebugProtocol.VariablesResponse);
-        } else if (message.type === 'response' && message.command === 'stackTrace') {
-            // This should be the top frame. We need to use this to compute the value of a variable
-            this.updateStackFrame(message as DebugProtocol.StackTraceResponse);
         } else if (message.type === 'event' && message.event === 'terminated') {
             // When the debugger exits, make sure the variables are cleared
             this.lastKnownVariables = [];
@@ -240,12 +241,6 @@ export class DebuggerVariables implements IConditionalJupyterVariables, DebugAda
         }
     }
 
-    private updateStackFrame(stackResponse: DebugProtocol.StackTraceResponse) {
-        if (stackResponse.body.stackFrames[0]) {
-            this.topMostFrameId = stackResponse.body.stackFrames[0].id;
-        }
-    }
-
     private async getFullVariable(variable: IJupyterVariable, notebook: INotebook): Promise<IJupyterVariable> {
         // See if we imported or not into the kernel our special function
         await this.importDataFrameScripts(notebook);