[lldb] Enable use of dummy target from dwim-print

[kastiglione]

Summary

Allow dwim-print to evaluate expressions using the dummy target if no real
target exists.

This adds some parity to expression. With this, both of the following work:

lldb -o 'expr 1+2'
lldb -o 'dwim-print 1+2'

[kastiglione]

Add docstring to new test function

lldb/source/Commands/CommandObjectDWIMPrint.cpp

 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 
 using namespace llvm;
 using namespace lldb;
 using namespace lldb_private;
 
 CommandObjectDWIMPrint::CommandObjectDWIMPrint(CommandInterpreter &interpreter)
-    : CommandObjectRaw(
-          interpreter, "dwim-print", "Print a variable or expression.",
+    : CommandObjectRaw(interpreter, "dwim-print",
+                       "Print a variable or expression.",
                        "dwim-print [<variable-name> | <expression>]",
-          eCommandProcessMustBePaused | eCommandTryTargetAPILock |
-              eCommandRequiresFrame | eCommandProcessMustBeLaunched |
-              eCommandRequiresProcess) {}
+                       eCommandProcessMustBePaused | eCommandTryTargetAPILock) {
+}
 
 bool CommandObjectDWIMPrint::DoExecute(StringRef expr,
                                        CommandReturnObject &result) {
   // Ignore leading and trailing whitespace.
   expr = expr.trim();
 
   if (expr.empty()) {
     result.AppendErrorWithFormatv("'{0}' takes a variable or expression",
                                   m_cmd_name);
     return false;
   }
 
-  // eCommandRequiresFrame guarantees a frame.
-  StackFrame *frame = m_exe_ctx.GetFramePtr();
-  assert(frame);
-
   auto verbosity = GetDebugger().GetDWIMPrintVerbosity();
 
-  // First, try `expr` as the name of a variable.
-  {
+  // First, try `expr` as the name of a frame variable.
+  if (StackFrame *frame = m_exe_ctx.GetFramePtr()) {
     auto valobj_sp = frame->FindVariable(ConstString(expr));
     if (valobj_sp && valobj_sp->GetError().Success()) {
       if (verbosity == eDWIMPrintVerbosityFull)
         result.AppendMessageWithFormatv("note: ran `frame variable {0}`", expr);
       valobj_sp->Dump(result.GetOutputStream());
       result.SetStatus(eReturnStatusSuccessFinishResult);
       return true;
     }
   }
 
   // Second, also lastly, try `expr` as a source expression to evaluate.
   {
-    // eCommandRequiresProcess guarantees a target.
-    Target *target = m_exe_ctx.GetTargetPtr();
-    assert(target);
+    Target *target_ptr = m_exe_ctx.GetTargetPtr();
+    // Fallback to the dummy target, which can allow for expression evaluation.
+    Target &target = target_ptr ? *target_ptr : GetDummyTarget();
 
+    auto *exe_scope = m_exe_ctx.GetBestExecutionContextScope();
     ValueObjectSP valobj_sp;
-    if (target->EvaluateExpression(expr, frame, valobj_sp) ==
+    if (target.EvaluateExpression(expr, exe_scope, valobj_sp) ==
         eExpressionCompleted) {
       if (verbosity != eDWIMPrintVerbosityNone)
         result.AppendMessageWithFormatv("note: ran `expression -- {0}`", expr);
       valobj_sp->Dump(result.GetOutputStream());
       result.SetStatus(eReturnStatusSuccessFinishResult);
       return true;
     } else {
       if (valobj_sp)
         result.SetError(valobj_sp->GetError());
       else
         result.AppendErrorWithFormatv(
             "unknown error evaluating expression `{0}`", expr);
       return false;
     }
   }
 }

lldb/test/API/commands/dwim-print/TestDWIMPrint.py

 """
 Test dwim-print with variables, variable paths, and expressions.
 """
 
 import re
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class TestCase(TestBase):
-    def setUp(self):
-        TestBase.setUp(self)
-        self.build()
-        lldbutil.run_to_name_breakpoint(self, "main")
-
     def _run_cmd(self, cmd: str) -> str:
         """Run the given lldb command and return its output."""
         result = lldb.SBCommandReturnObject()
         self.ci.HandleCommand(cmd, result)
         return result.GetOutput().rstrip()
 
     PERSISTENT_VAR = re.compile(r"\$\d+")
 
def _expect_cmd(self, expr: str, base_cmd: str) -> None:
             patterns.append(self._mask_persistent_var(cmd_output))
         else:
             substrs.append(cmd_output)
 
         self.expect(f"dwim-print {expr}", substrs=substrs, patterns=patterns)
 
     def test_variables(self):
         """Test dwim-print with variables."""
+        self.build()
+        lldbutil.run_to_name_breakpoint(self, "main")
         vars = ("argc", "argv")
         for var in vars:
             self._expect_cmd(var, "frame variable")
 
     def test_variable_paths(self):
         """Test dwim-print with variable path expressions."""
+        self.build()
+        lldbutil.run_to_name_breakpoint(self, "main")
         exprs = ("&argc", "*argv", "argv[0]")
         for expr in exprs:
             self._expect_cmd(expr, "expression --")
 
     def test_expressions(self):
         """Test dwim-print with expressions."""
+        self.build()
+        lldbutil.run_to_name_breakpoint(self, "main")
         exprs = ("argc + 1", "(void)argc", "(int)abs(argc)")
         for expr in exprs:
             self._expect_cmd(expr, "expression --")
+
+    def test_dummy_target_expressions(self):
+        """Test dwim-print's ability to evaluate expressions without a target."""
+        self._expect_cmd("1 + 2", "expression --")