[lldb] tab completion for `thread plan discard`

[MrHate]

Summary

Dedicated completion for the command thread plan discard with a corresponding test case.

[JDevlieghere]

lldb/source/Target/Thread.cpp

1113

How about while(p) and incrementing i in plans.GetPlanByIndex.

1118

What's the reason for doing this rather than

p = plans.GetPlanByIndex(i + 1, false);

lldb/test/API/functionalities/completion/thread_plan_script.py

21

As pointed out by phab.

[MrHate]

1. refactored for-loop into while-loop;
2. added a new line at the end of thread_plan_script.py.

[teemperor]

+Jim, but this LGTM now (minus the kinda hidden increment, but I can fix that when merging).

lldb/source/Target/Thread.cpp

1117

I think having the i++ in its own statement makes it easier to spot where we increment it.

[jingham]

The implementation looks fine.

The ThreadPlan that you push doesn't make any sense. That's fine because you never ask it to do anything, but you never know what people will take as an example, so it might be good to give it a name or add a comment indicating that this is a non-functional toy.

[MrHate]

• Added a comment in thread_plan_script.py.

lldb/include/lldb/Target/Thread.h

 #include <string>
 #include <vector>
 
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/RegisterCheckpoint.h"
 #include "lldb/Target/StackFrameList.h"
 #include "lldb/Utility/Broadcaster.h"
+#include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-private.h"
 
 #define LLDB_THREAD_MAX_STOP_EXC_DATA 8
 
 namespace lldb_private {
public:
 
   virtual lldb::ThreadPlanSP
   QueueThreadPlanForStepScripted(bool abort_other_plans, const char *class_name,
                                  StructuredData::ObjectSP extra_args_sp,
                                  bool stop_other_threads, Status &status);
 
   // Thread Plan accessors:
 
+  /// Format the thread plan information for auto completion.
+  ///
+  /// \param[in] request
+  ///     The reference to the completion handler.
+  void AutoCompleteThreadPlans(CompletionRequest &request) const;
+
   /// Gets the plan which will execute next on the plan stack.
   ///
   /// \return
   ///     A pointer to the next executed plan.
   ThreadPlan *GetCurrentPlan() const;
 
   /// Unwinds the thread stack for the innermost expression plan currently
   /// on the thread plan stack.

lldb/source/Commands/CommandObjectThread.cpp

CommandObjectThreadPlanDiscard(CommandInterpreter &interpreter)
     arg.push_back(plan_index_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg);
   }
 
   ~CommandObjectThreadPlanDiscard() override = default;
 
+  void
+  HandleArgumentCompletion(CompletionRequest &request,
+                           OptionElementVector &opt_element_vector) override {
+    if (!m_exe_ctx.HasThreadScope() || request.GetCursorIndex())
+      return;
+
+    m_exe_ctx.GetThreadPtr()->AutoCompleteThreadPlans(request);
+  }
+
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     Thread *thread = m_exe_ctx.GetThreadPtr();
     if (args.GetArgumentCount() != 1) {
       result.AppendErrorWithFormat("Too many arguments, expected one - the "
                                    "thread plan index - but got %zu.",
                                    args.GetArgumentCount());
       result.SetStatus(eReturnStatusFailed);
       return false;

lldb/source/Target/Thread.cpp

void Thread::DiscardPlan() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
   ThreadPlanSP discarded_plan_sp = GetPlans().PopPlan();
 
   LLDB_LOGF(log, "Discarding plan: \"%s\", tid = 0x%4.4" PRIx64 ".",
             discarded_plan_sp->GetName(), 
             discarded_plan_sp->GetThread().GetID());
 }
 
+void Thread::AutoCompleteThreadPlans(CompletionRequest &request) const {
+  const ThreadPlanStack &plans = GetPlans();
+  if (!plans.AnyPlans())
+    return;
+
+  // Iterate from the second plan (index: 1) to skip the base plan.
+  ThreadPlanSP p;
+  uint32_t i = 1;
+  while (p = plans.GetPlanByIndex(i, false)) {
+    StreamString strm;
+    p->GetDescription(&strm, eDescriptionLevelInitial);
+    request.TryCompleteCurrentArg(std::to_string(i), strm.GetString());
+    i++;
+  }
+}
+
 ThreadPlan *Thread::GetCurrentPlan() const {
   return GetPlans().GetCurrentPlan().get();
 }
 
 ThreadPlanSP Thread::GetCompletedPlan() const {
   return GetPlans().GetCompletedPlan();
 }
 

lldb/test/API/functionalities/completion/TestCompletion.py

class CommandLineCompletionTestCase(TestBase):
 
     def test_settings_set_target_process_thread_dot(self):
         """Test that 'settings set target.process.thread.' completes to [
         'target.process.thread.step-avoid-regexp', 'target.process.thread.trace-thread']."""
         self.complete_from_to('settings set target.process.thread.',
                               ['target.process.thread.step-avoid-regexp',
                                'target.process.thread.trace-thread'])
 
+    def test_thread_plan_discard(self):
+        self.build()
+        (_, _, thread, _) = lldbutil.run_to_source_breakpoint(self,
+                                          'ptr_foo', lldb.SBFileSpec("main.cpp"))
+        self.assertTrue(thread)
+        self.complete_from_to('thread plan discard ', 'thread plan discard ')
+
+        source_path = os.path.join(self.getSourceDir(), "thread_plan_script.py")
+        self.runCmd("command script import '%s'"%(source_path))
+        self.runCmd("thread step-scripted -C thread_plan_script.PushPlanStack")
+        self.complete_from_to('thread plan discard ', 'thread plan discard 1')
+        self.runCmd('thread plan discard 1')
+
     def test_target_space(self):
         """Test that 'target ' completes to ['create', 'delete', 'list',
         'modules', 'select', 'stop-hook', 'variable']."""
         self.complete_from_to('target ',
                               ['create',
                                'delete',
                                'list',
                                'modules',

lldb/test/API/functionalities/completion/thread_plan_script.py

+#############################################################################
+# This script is just to provide a thread plan which won't be popped instantly
+# for the completion test. The thread plan class below won't really do anything
+# itself.
+
+import lldb
+
+class PushPlanStack:
+
+    def __init__(self, thread_plan, dict):
+        pass
+
+    def explains_stop(self, event):
+        return False
+
+    def should_stop(self, event):
+        return True
+
+    def should_step(self):
+        return True