[lldb-vscode] Include the return value in 'local' variables

[ivanhernandez13]

Summary

This provides a convenient way for the user to easily inspect a functions return value after
stepping out of a function.

lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py

class TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
     def test_darwin_dwarf_missing_obj_with_symbol_ondemand_enabled(self):
         '''
             Test that if we build a binary with DWARF in .o files and we remove
             the .o file for main.cpp, that we get a variable named "<error>"
             whose value matches the appriopriate error. Test with symbol_ondemand_enabled.
         '''
         initCommands = ['settings set symbols.load-on-demand true']
         self.darwin_dwarf_missing_obj(initCommands)
+
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_return_value(self):
+        '''
+            Test that local variables include a an entry for the return value
+            when stepping out of a function with a return value.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        source = "main.cpp"
+        breakpoint4_line = line_number(source, "// breakpoint 4")
+        lines = [breakpoint4_line]
+        breakpoint_ids = self.set_source_breakpoints(source, lines)
+        self.assertEqual(
+            len(breakpoint_ids), len(lines), "expect correct number of breakpoints"
+        )
+        self.continue_to_breakpoints(breakpoint_ids)
+        tid = self.vscode.get_thread_id()
+
+        # We haven't stepped out of a function with a return value so there
+        # should be no variable named 'Return value'.
+        locals = self.vscode.get_local_variables()
+        names = [var['name'] for var in locals]
+        self.assertNotIn('Return value', names)
+
+        self.stepOut(threadId=tid, waitForStop=True)
+        globals = self.vscode.get_local_variables()
+        global_names = [var['name'] for var in globals]
+        # The return value should only be included in the local scope.
+        self.assertNotIn('Return value', global_names)
+        return_value = self.get_local_as_int('Return value', threadId=tid)
+        self.assertEqual(return_value, 0,
+                        'verify "Return value" was set to 0 (0 != %i)' % (return_value))
+        

lldb/tools/lldb-vscode/JSONUtils.h

 /// \param[in] is_name_duplicated
 ///     Whether the same variable name appears multiple times within the same
 ///     context (e.g. locals). This can happen due to shadowed variables in
 ///     nested blocks.
 ///
 ///     As VSCode doesn't render two of more variables with the same name, we
 ///     apply a suffix to distinguish duplicated variables.
 ///
+/// \param[in] name_override
+///     A name to give the variable when a predetermined name is known.
+///     Otherwise, the name is derived from the variable.
+///
 /// \return
 ///     A "Variable" JSON object with that follows the formal JSON
 ///     definition outlined by Microsoft.
 llvm::json::Value CreateVariable(lldb::SBValue v, int64_t variablesReference,
                                  int64_t varID, bool format_hex,
-                                 bool is_name_duplicated = false);
+                                 bool is_name_duplicated = false,
+                                 const char *name_override = nullptr);
 
 llvm::json::Value CreateCompileUnit(lldb::SBCompileUnit unit);
 
 /// Create a runInTerminal reverse request object
 ///
 /// \param[in] launch_request
 ///     The original launch_request object whose fields are used to construct
 ///     the reverse request object.

lldb/tools/lldb-vscode/JSONUtils.cpp

 //                       can use this optional information to present the
 //                       children in a paged UI and fetch them in chunks."
 //     }
 //   },
 //   "required": [ "name", "value", "variablesReference" ]
 // }
 llvm::json::Value CreateVariable(lldb::SBValue v, int64_t variablesReference,
                                  int64_t varID, bool format_hex,
-                                 bool is_name_duplicated) {
+                                 bool is_name_duplicated,
+                                 const char *name_override) {
   llvm::json::Object object;
-  EmplaceSafeString(object, "name",
-                    CreateUniqueVariableNameForDisplay(v, is_name_duplicated));
+  auto name = name_override
+                  ? name_override
+                  : CreateUniqueVariableNameForDisplay(v, is_name_duplicated);
+  EmplaceSafeString(object, "name", name);
 
   if (format_hex)
     v.SetFormat(lldb::eFormatHex);
   SetValueForKey(v, object, "value");
   auto type_obj = v.GetType();
   auto type_cstr = type_obj.GetDisplayTypeName();
   // If we have a type with many many children, we would like to be able to
   // give a hint to the IDE that the type has indexed children so that the

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

if (variablesReference == VARREF_REGS) {
       for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
         lldb::SBValue reg = reg_set.GetChildAtIndex(reg_idx);
         const lldb::Format format = reg.GetFormat();
         if (format == lldb::eFormatDefault || format == lldb::eFormatHex) {
           if (reg.GetByteSize() == addr_size)
             reg.SetFormat(lldb::eFormatAddressInfo);
         }
       }
+    } else if (variablesReference == VARREF_LOCALS) {
+      auto return_value =
+          g_vsc.target.GetProcess().GetSelectedThread().GetStopReturnValue();
+      if (return_value.IsValid()) {
+        int64_t var_ref = 0;
+        if (return_value.MightHaveChildren()) {
+          var_ref = g_vsc.variables.InsertExpandableVariable(
+              return_value, /*is_permanent=*/false);
+        }
+        variables.emplace_back(CreateVariable(
+            return_value, var_ref, var_ref != 0 ? var_ref : UINT64_MAX, hex,
+            /*is_name_duplicated=*/false, "Return value"));
+      }
     }
 
     num_children = top_scope->GetSize();
     if (num_children == 0 && variablesReference == VARREF_LOCALS) {
       // Check for an error in the SBValueList that might explain why we don't
       // have locals. If we have an error display it as the sole value in the
       // the locals.