[lldb-vscode] Added support for ‘totalFrames’ field in StackTraces response

[serhiy.redko]

Summary

The field ‘totalFrames’, total number of frames available, is mandatary in StackTraces response for VSCode extension that implements DAP and declares capability 'supportsDelayedStackTraceLoading':

"The debug adapter supports the delayed loading of parts of the stack,
which requires that both the 'startFrame' and 'levels' arguments and the
'totalFrames' result of the 'StackTrace' request are supported."

Lack of this field makes VSCode incorrectly display stack traces information

[lanza]

LGTM. Any concerns @clayborg?

[clayborg]

I seems this is optional in https://microsoft.github.io/debug-adapter-protocol/specification

interface StackTraceResponse extends Response {
  body: {
    /**
     * The frames of the stackframe. If the array has length zero, there are no stackframes available.
     * This means that there is no location information available.
     */
    stackFrames: StackFrame[];

    /**
     * The total number of frames available.
     */
    totalFrames?: number;
  };
}

It is nice to not have to send this back because if you have 300,000 stack frames due to a stack overflow, it can take quite a while to count up all 300,000 frames just so we can tell the DAP this large number. Where did you see this was mandatory?

[clayborg]

If this does make things not behave correctly, we should add it in, I don't have any problem with it since most of the time we won't have that many stack frames.

[serhiy.redko]

Thanks @clayborg ,

Basically I also was confused with that field which is marked as optional in schema and initially I thought this is VSCode UI issue that expects that field to be present for DAP implementations that provide support for 'supportsDelayedStackTraceLoading' capability.
Then I read the following in specification for 'supportsDelayedStackTraceLoading' and concluded that for DAP that supports 'supportsDelayedStackTraceLoading', 'totalFrames' field is mandatory.

/**
  * The debug adapter supports the delayed loading of parts of the stack, which requires that both the 'startFrame' and 'levels' arguments and the 'totalFrames' result of the 'StackTrace' request are supported.
  */
 supportsDelayedStackTraceLoading?: boolean;

Please let me know if you are disagree and with your appropriate arguments I can submit/fix issue in VSCode.

[lanza]

This was landed.

[clayborg]

No worries. Large large stacks are rare and I would rather backtraces work correctly in the IDE if the schema was wrong. Sorry for the delay, medical issues for the past few months on my end.

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py

                                     key, key_path, d))
         return value
 
-    def get_stackFrames(self, threadId=None, startFrame=None, levels=None,
-                        dump=False):
+    def get_stackFrames_and_totalFramesCount(self, threadId=None, startFrame=None, 
+                        levels=None, dump=False):
         response = self.vscode.request_stackTrace(threadId=threadId,
                                                   startFrame=startFrame,
                                                   levels=levels,
                                                   dump=dump)
         if response:
-            return self.get_dict_value(response, ['body', 'stackFrames'])
-        return None
+            stackFrames = self.get_dict_value(response, ['body', 'stackFrames'])
+            totalFrames = self.get_dict_value(response, ['body', 'totalFrames'])
+            self.assertTrue(totalFrames > 0,
+                    'verify totalFrames count is provided by extension that supports '
+                    'async frames loading')
+            return (stackFrames, totalFrames)
+        return (None, 0)
+
+    def get_stackFrames(self, threadId=None, startFrame=None, levels=None,
+                        dump=False):
+        (stackFrames, totalFrames) = self.get_stackFrames_and_totalFramesCount(
+                                                threadId=threadId,
+                                                startFrame=startFrame,
+                                                levels=levels,
+                                                dump=dump)
+        return stackFrames
 
     def get_source_and_line(self, threadId=None, frameIndex=0):
         stackFrames = self.get_stackFrames(threadId=threadId,

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/stackTrace/TestVSCode_stackTrace.py

         self.continue_to_breakpoints(breakpoint_ids)
         startFrame = 0
         # Verify we get all stack frames with no arguments
-        stackFrames = self.get_stackFrames()
+        (stackFrames, totalFrames) = self.get_stackFrames_and_totalFramesCount()
         frameCount = len(stackFrames)
         self.assertTrue(frameCount >= 20,
                         'verify we get at least 20 frames for all frames')
+        self.assertTrue(totalFrames == frameCount,
+                        'verify we get correct value for totalFrames count')
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Verify all stack frames by specifying startFrame = 0 and levels not

         # Verify we cap things correctly when we ask for too many frames
         startFrame = 5
         levels = 1000
-        stackFrames = self.get_stackFrames(startFrame=startFrame,
-                                           levels=levels)
+        (stackFrames, totalFrames) = self.get_stackFrames_and_totalFramesCount(
+                                            startFrame=startFrame,
+                                            levels=levels)
         self.assertTrue(len(stackFrames) == frameCount - startFrame,
                         ('verify less than 1000 frames with startFrame=%i and'
                          ' levels=%i') % (startFrame, levels))
+        self.assertTrue(totalFrames == frameCount,
+                        'verify we get correct value for totalFrames count '
+                        'when requested frames not from 0 index')
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Verify level=0 works with non-zerp start frame

lldb/tools/lldb-vscode/lldb-vscode.cpp

         break;
       stackFrames.emplace_back(CreateStackFrame(frame));
     }
+    const auto totalFrames = thread.GetNumFrames();
+    body.try_emplace("totalFrames", totalFrames);
   }
   body.try_emplace("stackFrames", std::move(stackFrames));
   response.try_emplace("body", std::move(body));