[lldb] Suppress persistent result when running po

[kastiglione]

Summary

Remove the persistent result variable after executing po.

Without this change, the following behavior happens:

(lldb) p thing
(NSObject *) $0 = 0x600000008000
(lldb) po thing
<NSObject: 0x600000008000>
(lldb) p thing
(NSObject *) $2 = 0x600000008000
(lldb) p $1
(NSObject *) $1 = 0x600000008000

Even though po hides the persistent result variable, it's still created - as $1 in
this example. It can be accessed even though its existence is not evident.

With this change, the persistent result is removed after the object description has
printed. Instead, this is the behavior:

(lldb) p thing
(NSObject *) $0 = 0x600000008000
(lldb) po thing
<NSObject: 0x600000008000>
(lldb) p thing
(NSObject *) $1 = 0x600000008000

The difference here is that the po doens't silently create a persistent result.

[kastiglione]

I'll update with a test.

[kastiglione]

Respect verbosity level

[kastiglione]

Add tests

lldb/source/Commands/CommandObjectExpression.cpp

 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandOptionArgumentTable.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
+#include "lldb/lldb-private-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 CommandObjectExpression::CommandOptions::CommandOptions() = default;
 
 CommandObjectExpression::CommandOptions::~CommandOptions() = default;
 
if (pointee.IsVoidType())
     return Status("as it refers to a pointer to void");
   return Status();
 }
 
 EvaluateExpressionOptions
 CommandObjectExpression::GetEvalOptions(const Target &target) {
   EvaluateExpressionOptions options;
   options.SetCoerceToId(m_varobj_options.use_objc);
+  if (m_command_options.m_verbosity ==
+      eLanguageRuntimeDescriptionDisplayVerbosityCompact)
+    options.SetSuppressPersistentResult(m_varobj_options.use_objc);
   options.SetUnwindOnError(m_command_options.unwind_on_error);
   options.SetIgnoreBreakpoints(m_command_options.ignore_breakpoints);
   options.SetKeepInMemory(true);
   options.SetUseDynamic(m_varobj_options.use_dynamic);
   options.SetTryAllThreads(m_command_options.try_all_threads);
   options.SetDebug(m_command_options.debug);
   options.SetLanguage(m_command_options.language);
   options.SetExecutionPolicy(

lldb/test/API/commands/expression/po_persistent_result/Makefile

+OBJC_SOURCES := main.m
+
+include Makefile.rules

lldb/test/API/commands/expression/po_persistent_result/TestPoPersistentResult.py

+"""
+Test behavior of `po` and persistent results.
+"""
+
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestCase(TestBase):
+    def setUp(self):
+        TestBase.setUp(self)
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "break here", lldb.SBFileSpec("main.m"))
+
+    def test_po_does_not_print_persistent_result(self):
+        """Test `po` doesn't advertise a persistent result variable."""
+        self.expect("po obj", matching=False, substrs=["$0 = "])
+
+    def test_po_does_not_keep_persistent_result(self):
+        """Test `po` doesn't leak a persistent result variable."""
+        self.expect("po obj")
+        # Verify `po` used a temporary persistent result. In other words, there
+        # should be no $0 at this point.
+        self.expect("expression $0", error=True)
+        self.expect("expression obj", substrs=["$0 = "])
+
+    def test_expression_description_verbosity(self):
+        """Test printing object description _and_ opt-in to persistent results."""
+        self.expect("expression -O -vfull -- obj", substrs=["$0 = "])
+        self.expect("expression $0", substrs=["$0 = "])

lldb/test/API/commands/expression/po_persistent_result/main.m

+#import <objc/NSObject.h>
+
+int main() {
+  NSObject *obj = [NSObject new];
+  return 0; // break here
+}