[lldb] Fix that running a top level expression without a process fails with a cryptic error

[teemperor]

Summary

Right now when running expr --top-level -- void foo() {}, LLDB just prints a cryptic
error: Couldn't find $__lldb_expr() in the module error. The reason for that is
that if we don't have a running process, we try to set our execution policy to always use the
IR interpreter (ExecutionPolicyNever) which works even without a process. However
that code didn't consider the special ExecutionPolicyTopLevel which we use for
top-level expressions. By changing the execution policy to ExecutionPolicyNever,
LLDB thinks we're actually trying to interpret a normal expression inside our
$__lldb_expr function and then fails when looking for it.

This just adds an exception for top-level expressions to that code and a bunch of tests.

[shafik]

Interesting so we always had the error Top-level code needs to be inserted into a runnable target but we just were not triggering it before?

[teemperor]

In D91723#2403928, @shafik wrote:

Interesting so we always had the error Top-level code needs to be inserted into a runnable target but we just were not triggering it before?

Jepp, that error was added in the commit that introduced top-level expressions:

commit 00294b34a3c99f3540214a148c0bd15e68f9d7fd
Author: Sean Callanan <[e-mail]>, Tue Mar 22 21:05:51 2016 +0000 (4 years, 8 months ago)

[shafik]

LGTM

lldb/source/Expression/UserExpression.cpp

if (execution_policy == eExecutionPolicyAlways) {
                     "is not constant ==");
 
       error.SetErrorString("expression needed to run but couldn't");
 
       return execution_results;
     }
   }
 
-  if (process == nullptr || !process->CanJIT())
+  // Explicitly force the IR interpreter to evaluate the expression when the
+  // there is no process that supports running the expression for us. Don't
+  // change the execution policy if we have the special top-level policy that
+  // doesn't contain any expression and there is nothing to interpret.
+  if (execution_policy != eExecutionPolicyTopLevel &&
+      (process == nullptr || !process->CanJIT()))
     execution_policy = eExecutionPolicyNever;
 
   // We need to set the expression execution thread here, turns out parse can
   // call functions in the process of looking up symbols, which will escape the
   // context set by exe_ctx passed to Execute.
   lldb::ThreadSP thread_sp = exe_ctx.GetThreadSP();
   ThreadList::ExpressionExecutionThreadPusher execution_thread_pusher(
       thread_sp);

lldb/test/API/commands/expression/static-initializers/TestStaticInitializers.py

def test_failing_init(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 
         # FIXME: This error message is not even remotely helpful.
         self.expect("expr -p -- struct Foo2 { Foo2() { do_abort(); } }; Foo2 f;", error=True,
                     substrs=["error: couldn't run static initializer:"])
+
+    def test_without_process(self):
+        """ Test a static initializer without a running process. """
+        self.expect("expr -p -- int i = 0; struct Foo3 { Foo3() { ++i; } }; Foo3 f;", error=True,
+                    substrs=["Top-level code needs to be inserted into a runnable target"])

lldb/test/API/commands/expression/top-level/TestTopLevelExprs.py

def test_top_level_expressions(self):
             self.frame().EvaluateExpression(expression, options)
 
         resultFromTopLevel = self.frame().EvaluateExpression("doTest()")
 
         self.assertTrue(resultFromTopLevel.IsValid())
         self.assertEqual(
             resultFromCode,
             resultFromTopLevel.GetValueAsUnsigned())
+
+    def test_top_level_expression_without_target(self):
+        self.expect("expr --top-level -- void func() {}", error=True,
+                    substrs=["Top-level code needs to be inserted into a runnable target"])
+
+        # FIXME: This doesn't actually generate any code, so LLDB should probably
+        # allow these expressions.
+        self.expect("expr --top-level -- template<typename T> struct StructT { T m; };", error=True,
+                    substrs=["Top-level code needs to be inserted into a runnable target"])
+        self.expect("expr --top-level -- struct Struct { int i; };", error=True,
+                    substrs=["Top-level code needs to be inserted into a runnable target"])

lldb/test/API/lang/cpp/elaborated-types/TestElaboratedTypes.py

def test(self):
         self.assertEqual(result.GetTypeName(), "Struct")
 
         # Test the same for template types (that also only act as sugar to better
         # show how the template was specified by the user).
 
         # Declare a template that can actually be instantiated.
         # FIXME: The error message here is incorrect.
         self.expect("expr --top-level -- template<typename T> struct $V {};",
-                    error=True, substrs=["Couldn't find $__lldb_expr() in the module"])
+                    error=True, substrs=["Top-level code needs to be inserted into a runnable target"])
         result = self.expect_expr("$V<::Struct> s; s",
                                   result_type="$V< ::Struct>")
         self.assertEqual(result.GetTypeName(), "$V<Struct>")