Fix and simplify lldb.command decorator

[kastiglione]

Summary

This change fixes one issue with lldb.command, and also reduces the implementation.

The fix: a command function's docstring was not shown when running help <command_name>. This is because the docstring attached the source function is not propagated to the decorated function (f.__call__). By returning the original function, the docstring will be properly displayed by help.

Also with this change, the command name is assumed to be the function's name, but can still be explicitly defined as previously.

Additionally, the implementation was updated to:

• Remove inner class
• Remove use of inspect module
• Remove *args and **kwargs

[kastiglione]

Update a comment

[granata.enrico]

Thanks for doing this work.

I stopped working on lldb a couple years ago, so I removed myself as a reviewer. Greg will take good care of you I'm sure.

[kastiglione]

Thanks @granata.enrico, sorry for the disruption, I noticed previous comments after I had submitted this.

[clayborg]

Can we add a test for this to ensure all functionality that we want? I recently made changes to the cmdtemplate.py. Maybe we can integrate some more functionality that auto registers a class somehow?

[kastiglione]

@clayborg I'll dig into how python-extensions.swig gets tested, and add something accordingly.

I have only briefly looked at cmdtemplate.py. I can look into adding similar registration behavior to it. For what it's worth, I prefer functions to classes for defining commands.

[kastiglione]

Add tests and make command_name optional

lldb/trunk/packages/Python/lldbsuite/test/functionalities/command_script/TestCommandScript.py

def pycmd_tests(self):
             self.runCmd('command script delete targetname', check=False)
             self.runCmd('command script delete longwait', check=False)
             self.runCmd('command script delete mysto', check=False)
             self.runCmd('command script delete tell_sync', check=False)
             self.runCmd('command script delete tell_async', check=False)
             self.runCmd('command script delete tell_curr', check=False)
             self.runCmd('command script delete bug11569', check=False)
             self.runCmd('command script delete takes_exe_ctx', check=False)
+            self.runCmd('command script delete decorated', check=False)
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         # Interact with debugger in synchronous mode
         self.setAsync(False)
 
         # We don't want to display the stdout if not in TraceOn() mode.
         if not self.TraceOn():
             self.HideStdout()
 
         self.expect('welcome Enrico',
                     substrs=['Hello Enrico, welcome to LLDB'])
 
         self.expect("help welcome",
                     substrs=['Just a docstring for welcome_impl',
                              'A command that says hello to LLDB users'])
 
+        decorated_commands = ["decorated" + str(n) for n in range(1, 5)]
+        for name in decorated_commands:
+            self.expect(name, substrs=["hello from " + name])
+            self.expect("help " + name,
+                        substrs=["Python command defined by @lldb.command"])
+
         self.expect("help",
                     substrs=['For more information run',
-                             'welcome'])
+                             'welcome'] + decorated_commands)
 
         self.expect("help -a",
                     substrs=['For more information run',
-                             'welcome'])
+                             'welcome'] + decorated_commands)
 
         self.expect("help -u", matching=False,
                     substrs=['For more information run'])
 
         self.runCmd("command script delete welcome")
 
         self.expect('welcome Enrico', matching=False, error=True,
                     substrs=['Hello Enrico, welcome to LLDB'])

lldb/trunk/packages/Python/lldbsuite/test/functionalities/command_script/decorated.py

+from __future__ import print_function
+
+import lldb
+
+
[e-mail]()
+def decorated1(debugger, args, exe_ctx, result, dict):
+    """
+    Python command defined by @lldb.command
+    """
+    print("hello from decorated1", file=result)
+
+
[e-mail](doc="Python command defined by @lldb.command")
+def decorated2(debugger, args, exe_ctx, result, dict):
+    """
+    This docstring is overridden.
+    """
+    print("hello from decorated2", file=result)
+
+
[e-mail]()
+def decorated3(debugger, args, result, dict):
+    """
+    Python command defined by @lldb.command
+    """
+    print("hello from decorated3", file=result)
+
+
[e-mail]("decorated4")
+def _decorated4(debugger, args, exe_ctx, result, dict):
+    """
+    Python command defined by @lldb.command
+    """
+    print("hello from decorated4", file=result)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/command_script/py_import

 script import sys, os
 script sys.path.append(os.path.join(os.getcwd(), os.pardir))
 script import welcome
 script import bug11569
 command script add welcome --class welcome.WelcomeCommand
 command script add targetname --class welcome.TargetnameCommand
 command script add longwait --function welcome.print_wait_impl
 command script import mysto.py --allow-reload
 command script add tell_sync --function welcome.check_for_synchro --synchronicity sync
 command script add tell_async --function welcome.check_for_synchro --synchronicity async
 command script add tell_curr --function welcome.check_for_synchro --synchronicity curr
 command script add takes_exe_ctx --function welcome.takes_exe_ctx
+command script import decorated.py

lldb/trunk/scripts/Python/python-extensions.swig

 //             // Only call Py_XDECREF if we have a Python object (or NULL)
 //             if (LLDBSwigPythonCallPythonLogOutputCallback == $self->GetLogOutPutCallback())
 //                 Py_XDECREF($self->GetCallbackBaton());
 //         }
 // }
 
 %pythoncode %{
 
-def command(*args, **kwargs):
+def command(command_name=None, doc=None):
     import lldb
-    import inspect
     """A decorator function that registers an LLDB command line
         command that is bound to the function it is attached to."""
-    class obj(object):
-        """The object that tracks adding the command to LLDB one time and handles
-            calling the function on subsequent calls."""
-        def __init__(self, function, command_name, doc = None):
-            if doc:
-                function.__doc__ = doc
-            command = "command script add -f %s.%s %s" % (function.__module__, function.__name__, command_name)
-            lldb.debugger.HandleCommand(command)
-            self.function = function
-        def __call__(self, debugger, command, exe_ctx, result, dict):
-            if len(inspect.getargspec(self.function).args) == 5:
-                self.function(debugger, command, exe_ctx, result, dict)
-            else:
-                self.function(debugger, command, result, dict)
-    def callable(function):
-        """Creates a callable object that gets used."""
-        f = obj(function, *args, **kwargs)
-        return f.__call__
+    def callable(function):
+        """Registers an lldb command for the decorated function."""
+        command = "command script add -f %s.%s %s" % (function.__module__, function.__name__, command_name or function.__name__)
+        lldb.debugger.HandleCommand(command)
+        return function
+
     return callable
 
 class declaration(object):
     '''A class that represents a source declaration location with file, line and column.'''
     def __init__(self, file, line, col):
         self.file = file
         self.line = line
         self.col = col