Specify a language to use when parsing expressions.

[dawn]

Summary

This patch adds the option -l/--language to the expression command, for use when setting the language options or choosing an alternate FE. If not specified, the target.language setting is used. It is the expression counterpart of http://reviews.llvm.org/D11119 which added the --language option to breakpoint set command.

[dawn]

Please review. I have another patch which depends on this one.

[clayborg]

Looks good.

[clayborg]

One thing you might want to fix is to use:

self.dbg.HandleCommand("...")

This avoids the need for the command to succeed.

[clayborg]

runCmd can take a named argument "check = False" that will stop the mandatory checking of the success of the command.

test/expression_command/options/TestExprOptions.py

37–42

Actually don't make tests that use runCmd for creating targets use the following code:

# Set debugger into synchronous mode
self.dbg.SetAsync(False)

# Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)

# Set breakpoints inside and outside methods that take pointers to the containing struct.
lldbutil.run_break_set_by_file_and_line (self, self.source, line, num_expected_locations=1, loc_exact=True)

# Register our shared libraries for remote targets so they get automatically uploaded
arguments = None
environment = None 

# Now launch the process, and do not stop at entry point.
process = target.LaunchSimple (arguments, environment, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID)

[clayborg]

See inlined comments.

test/expression_command/options/TestExprOptions.py

47–56

use self.runCmd(check=False,...) instead of self.expect(...). You should actually use the "lldb.SB*" API if possible unless you are explicitly trying to test textual output from commands. Please don't use self.expect() or self.runCmd() if you can use "lldb.SB*" API calls.

[dawn]

In D11447#211105, @clayborg wrote:

See inlined comments.

I am trying to check textual output from commands. expect() doesn't take a check=False option, and runCmd() doesn't check for output afaik. It would be possible to pipe all the output and check that way, but what a major pain.

How do you suggest I get this to fly?:

self.expect("expression blabla", startstr = "error")

I want to test that lldb returns error without FAILing

[dawn]

Ah! expect takes a 'error' argument :) This works:

self.expect("expression blabla", error=True, startstr = "error")

[clayborg]

To evaluate an expression use the SB API:

threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint)
self.assertTrue(len(threads) == 1)
thread = threads[0]
frame = thread.GetFrameAtIndex(0)

options = lldb.SBExpressionOptions()
value = frame.EvaluateExpression ("expression blabla", options)
self.assertTrue (value.GetError().Fail())

[clayborg]

There are many tests that evaluate expressions using the SB API:

expression_command/call-restarts/TestCallThatRestarts.py
expression_command/call-throws/TestCallThatThrows.py
expression_command/char/TestExprsChar.py
expression_command/formatters/TestFormatters.py
expression_command/test/TestExprs.py
expression_command/timeout/TestCallWithTimeout.py
functionalities/asan/TestMemoryHistory.py
functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py
functionalities/inline-stepping/TestInlineStepping.py
functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py
lang/c/stepping/TestStepAndBreakpoints.py
lang/cpp/dynamic-value/TestDynamicValue.py
lang/objc/blocks/TestObjCIvarsInBlocks.py
lang/objc/objc-checker/TestObjCCheckers.py
lang/objc/objc-class-method/TestObjCClassMethod.py
lang/objc/objc-dynamic-value/TestObjCDynamicValue.py
lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py
lang/objc/objc-property/TestObjCProperty.py
lang/objc/objc-static-method/TestObjCStaticMethod.py
lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py
lang/objc/objc-struct-argument/TestObjCStructArgument.py
lang/objc/objc-struct-return/TestObjCStructReturn.py
lang/objc/objc-super/TestObjCSuper.py
lang/swift/different_clang_flags/TestSwiftDifferentClangFlags.py
lang/swift/expression/access_control/TestExpressionAccessControl.py
lang/swift/expression/classes/TestExpressionInMethods.py
lang/swift/expression/errors/TestExpressionErrors.py
lang/swift/expression/generic/TestGenericExpressions.py
lang/swift/expression/scopes/TestExpressionScopes.py
lang/swift/expression/simple/TestSimpleExpressions.py
lang/swift/expression/static/TestGenericExpressions.py
lang/swift/file_private/TestFilePrivate.py
lang/swift/struct_change_rerun/TestSwiftStructChangeRerun.py
lang/swift/swiftieformatting/TestSwiftieFormatting.py
lang/swift/variables/globals/TestSwiftGlobals.py
lang/swift/variables/inout/TestInOutVariables.py
lldbinline.py
python_api/default-constructor/sb_frame.py
python_api/frame/TestFrames.py
python_api/value/TestValueAPI.py

[dawn]

Test case was fixed as directed.

[clayborg]

Please use SB API calls for expression evaluation instead of self.expect calls.

test/expression_command/options/TestExprOptions.py

57–87

Please use SB API calls for expression evaluation instead of self.expect calls.

[spyffe]

This all looks all right to me, except that we should print errors if C or Objective-C is requested, because we can only run in C++ or Objective-C++ mode.
We should be careful to switch away from ObjC++ only on request, and not based on the current compilation unit's language, but that's a different patch.

[dawn]

Changed test to use SB APIs.

[clayborg]

Looks good, thanks for fixing everything.

source/Commands/CommandObjectExpression.h

         bool        debug;
         uint32_t    timeout;
         bool        try_all_threads;
+        lldb::LanguageType language;
         LanguageRuntimeDescriptionDisplayVerbosity m_verbosity;
     };
 

source/Commands/CommandObjectExpression.cpp

     { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "timeout",            't', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeUnsignedInteger,  "Timeout value (in microseconds) for running the expression."},
     { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "unwind-on-error",    'u', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean,    "Clean up program state if the expression causes a crash, or raises a signal.  Note, unlike gdb hitting a breakpoint is controlled by another option (-i)."},
     { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "debug",              'g', OptionParser::eNoArgument      , NULL, NULL, 0, eArgTypeNone,       "When specified, debug the JIT code by setting a breakpoint on the first instruction and forcing breakpoints to not be ignored (-i0) and no unwinding to happen on error (-u0)."},
+    { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "language",           'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLanguage,   "Specifies the Language to use when parsing the expression.  If not set the target.language setting is used." },
     { LLDB_OPT_SET_1, false, "description-verbosity", 'v', OptionParser::eOptionalArgument, NULL, g_description_verbosity_type, 0, eArgTypeDescriptionVerbosity,        "How verbose should the output of this expression be, if the object description is asked for."},
 };
 

 
     switch (short_option)
     {
-      //case 'l':
-      //if (language.SetLanguageFromCString (option_arg) == false)
-      //{
-      //    error.SetErrorStringWithFormat("invalid language option argument '%s'", option_arg);
-      //}
-      //break;
+    case 'l':
+        language = LanguageRuntime::GetLanguageTypeFromString (option_arg);
+        if (language == eLanguageTypeUnknown)
+            error.SetErrorStringWithFormat ("unknown language type: '%s' for expression", option_arg);
+        break;
 
     case 'a':
         {

     try_all_threads = true;
     timeout = 0;
     debug = false;
+    language = eLanguageTypeUnknown;
     m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityCompact;
 }
 

 CommandObjectExpression::CommandObjectExpression (CommandInterpreter &interpreter) :
     CommandObjectRaw (interpreter,
                       "expression",
-                      "Evaluate a C/ObjC/C++ expression in the current program context, using user defined variables and variables currently in scope.",
+                      "Evaluate an expression in the current program context, using user defined variables and variables currently in scope.",
                       NULL,
                       eCommandProcessMustBePaused | eCommandTryTargetAPILock),
     IOHandlerDelegate (IOHandlerDelegate::Completion::Expression),

         options.SetTryAllThreads(m_command_options.try_all_threads);
         options.SetDebug(m_command_options.debug);
         
+        // If the language was not specified, set it from target's properties
+        if (m_command_options.language != eLanguageTypeUnknown)
+            options.SetLanguage(m_command_options.language);
+        else
+            options.SetLanguage(target->GetLanguage());
+
         // If there is any chance we are going to stop and want to see
         // what went wrong with our expression, we should generate debug info
         if (!m_command_options.ignore_breakpoints ||

test/expression_command/options/Makefile

+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp foo.cpp
+
+include $(LEVEL)/Makefile.rules

test/expression_command/options/TestExprOptions.py

+"""
+Test expression command options.
+
+Test cases:
+
+o test_expr_options:
+  Test expression command options.
+"""
+
+import os, time
+import unittest2
+import lldb
+import lldbutil
+from lldbtest import *
+
+class ExprOptionsTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break for main.cpp.
+        self.line = line_number('main.cpp',
+                                '// breakpoint_in_main')
+
+        # Disable confirmation prompt to avoid infinite wait
+        self.runCmd("settings set auto-confirm true")
+        self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
+
+    def build_and_run(self):
+        """These expression command options should work as expected."""
+        self.buildDefault()
+
+        # Set debugger into synchronous mode
+        self.dbg.SetAsync(False)
+
+        # Create a target by the debugger.
+        exe = os.path.join(os.getcwd(), "a.out")
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # Set breakpoints inside and outside methods that take pointers to the containing struct.
+        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
+
+        # Register our shared libraries for remote targets so they get automatically uploaded
+        arguments = None
+        environment = None 
+
+        # Now launch the process, and do not stop at entry point.
+        process = target.LaunchSimple (arguments, environment, self.get_process_working_directory())
+        self.assertTrue(process, PROCESS_IS_VALID)
+
+    def test_expr_options(self):
+        self.build_and_run()
+
+        # -- test --language on ObjC builtin type --
+        # Make sure we can evaluate the ObjC builtin type 'id':
+        self.expect("expr id my_id = 0; my_id",
+            substrs = ["= nil"])
+        # Make sure it still works if language is set to ObjC:
+        self.expect("expr -l objc -- id my_id = 0; my_id",
+            substrs = ["= nil"])
+        # Make sure it fails if language is set to C:
+        self.expect("expr -l c -- id my_id = 0; my_id", error=True,
+            startstr = "error")
+        # Make sure it fails if the target's language is set to C:
+        self.runCmd("settings set target.language c")
+        self.expect("expr id my_id = 0; my_id", error=True,
+            startstr = "error")
+        self.runCmd("settings clear target.language")
+
+        # -- test --language on C++ expression --
+        # Make sure we can evaluate 'ns::func'.
+        self.expect("expr ns::func",
+            patterns = ["\(int .* = 0x.*"])
+        # Make sure it still works if language is set to C++:
+        self.expect("expr -l c++ -- ns::func",
+            patterns = ["\(int .* = 0x.*"])
+        # Make sure it fails if language is set to C:
+        self.expect("expr -l c -- ns::func", error=True,
+            startstr = "error")
+        # Make sure it fails if the target's language is set to C:
+        self.runCmd("settings set target.language c")
+        self.expect("expr ns::func", error=True,
+            startstr = "error")
+        self.runCmd("settings clear target.language")
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

test/expression_command/options/foo.cpp

+namespace ns {
+    int func(void)
+    {
+        return 0;
+    }
+}
+
+extern "C" int foo(void)
+{
+    return ns::func();
+}

test/expression_command/options/main.cpp

+extern "C" int foo(void);
+static int static_value = 0;
+
+int
+bar()
+{
+    static_value++;
+    return static_value;
+}
+
+int main (int argc, char const *argv[])
+{
+    // breakpoint_in_main
+    bar();
+    return foo();
+}