[lldb] Rename QueueFundamentalPlan to QueueBasePlan (NFC)

[kastiglione]

Summary

Minor change for naming consistency.

[jingham]

Yeah, apparently I got tired of typing Fundamental pretty quickly...

lldb/include/lldb/Target/Thread.h

public:
   /// \param[in] abort_other_plans
   ///    \b true if we discard the currently queued plans and replace them with
   ///    this one.
   ///    Otherwise this plan will go on the end of the plan stack.
   ///
   /// \return
   ///     A shared pointer to the newly queued thread plan, or nullptr if the
   ///     plan could not be queued.
-  virtual lldb::ThreadPlanSP QueueFundamentalPlan(bool abort_other_plans);
+  lldb::ThreadPlanSP QueueBasePlan(bool abort_other_plans);
 
   /// Queues the plan used to step one instruction from the current PC of \a
   /// thread.
   ///
   /// \param[in] step_over
   ///    \b true if we step over calls to functions, false if we step in.
   ///
   /// \param[in] abort_other_plans

lldb/include/lldb/Target/ThreadPlanBase.h

public:
   bool IsBasePlan() override { return true; }
 
 protected:
   bool DoWillResume(lldb::StateType resume_state, bool current_plan) override;
   bool DoPlanExplainsStop(Event *event_ptr) override;
   ThreadPlanBase(Thread &thread);
 
 private:
-  friend lldb::ThreadPlanSP
-  Thread::QueueFundamentalPlan(bool abort_other_plans);
+  friend lldb::ThreadPlanSP Thread::QueueBasePlan(bool abort_other_plans);
 
   ThreadPlanBase(const ThreadPlanBase &) = delete;
   const ThreadPlanBase &operator=(const ThreadPlanBase &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANBASE_H

lldb/source/Target/Thread.cpp

Status Thread::UnwindInnermostExpression() {
   if (!innermost_expr_plan) {
     error.SetErrorString("No expressions currently active on this thread");
     return error;
   }  
   DiscardThreadPlansUpToPlan(innermost_expr_plan);
   return error;
 }
 
-ThreadPlanSP Thread::QueueFundamentalPlan(bool abort_other_plans) {
+ThreadPlanSP Thread::QueueBasePlan(bool abort_other_plans) {
   ThreadPlanSP thread_plan_sp(new ThreadPlanBase(*this));
   QueueThreadPlan(thread_plan_sp, abort_other_plans);
   return thread_plan_sp;
 }
 
 ThreadPlanSP Thread::QueueThreadPlanForStepSingleInstruction(
     bool step_over, bool abort_other_plans, bool stop_other_threads,
     Status &status) {

lldb/source/Target/ThreadPlanStack.cpp

void ThreadPlanStackMap::Update(ThreadList &current_threads,
                                 bool check_for_new) {
 
   // Now find all the new threads and add them to the map:
   if (check_for_new) {
     for (auto thread : current_threads.Threads()) {
       lldb::tid_t cur_tid = thread->GetID();
       if (!Find(cur_tid)) {
         AddThread(*thread.get());
-        thread->QueueFundamentalPlan(true);
+        thread->QueueBasePlan(true);
       }
     }
   }
 
   // If we aren't reaping missing threads at this point,
   // we are done.
   if (!delete_missing)
     return;