[lldb][NFC] Don't let Process inherit from UserID

[teemperor]

Summary

I noticed that Process is inheriting from UserID to store its PID value. This patch
replaces this with a dedicated field in the Process class. This is NFC, but has some
small effects on the code using Process:

• GetID() now returns a lldb::pid_t like all other process code instead of lldb::user_id_t. Both are typedefs for uint64_t, so no change in behaviour.
• The equality operators defined for UserID no longer accept Process instances.
• Removes the inherited method Process::Clear() which didn't actually clear anything beside the PID value.

We maybe should also remove the getters/setters to S/GetPID or something like that. I can update all the code for that
in a follow-up NFC commit.

[labath]

Seems reasonable. I don't think that renaming to [GS]etP(rocess)ID is necessary, but I am not against it either.

lldb/include/lldb/Target/Process.h

2741

lldb::pid_t

lldb/include/lldb/Target/Process.h

 inline bool operator!=(const ProcessModID &lhs, const ProcessModID &rhs) {
   return (!lhs.StopIDEqual(rhs) || !lhs.MemoryIDEqual(rhs));
 }
 
 /// \class Process Process.h "lldb/Target/Process.h"
 /// A plug-in interface definition class for debugging a process.
 class Process : public std::enable_shared_from_this<Process>,
                 public ProcessProperties,
-                public UserID,
                 public Broadcaster,
                 public ExecutionContextScope,
                 public PluginInterface {
   friend class FunctionCaller; // For WaitForStateChangeEventsPrivate
   friend class Debugger; // For PopProcessIOHandler and ProcessIOHandlerIsActive
   friend class DynamicLoader; // For LoadOperatingSystemPlugin
   friend class ProcessEventData;
   friend class StopInfo;
SetProcessExitStatus(lldb::pid_t pid, // The process ID we want to monitor
                        bool exited,
                        int signo,   // Zero for no signal
                        int status); // Exit value of process if signal is zero
 
   lldb::ByteOrder GetByteOrder() const;
 
   uint32_t GetAddressByteSize() const;
 
+  /// Sets the stored pid.
+  ///
+  /// This does not change the pid of underlying process.
+  lldb::pid_t GetID() const { return m_pid; }
+
+  /// Returns the pid of the process or LLDB_INVALID_PROCESS_ID if there is
+  /// no known pid.
+  void SetID(lldb::pid_t new_pid) { m_pid = new_pid; }
+
   uint32_t GetUniqueID() const { return m_process_unique_id; }
 
   /// Check if a plug-in instance can debug the file in \a module.
   ///
   /// Each plug-in is given a chance to say whether it can debug the file in
   /// \a module. If the Process plug-in instance can debug a file on the
   /// current system, it should return \b true.
   ///
struct PreResumeCallbackAndBaton {
     }
   };
 
   using StructuredDataPluginMap =
       std::map<ConstString, lldb::StructuredDataPluginSP>;
 
   // Member variables
   std::weak_ptr<Target> m_target_wp; ///< The target that owns this process.
+  lldb::pid_t m_pid = LLDB_INVALID_PROCESS_ID;
   ThreadSafeValue<lldb::StateType> m_public_state;
   ThreadSafeValue<lldb::StateType>
       m_private_state;                     // The actual state of our process
   Broadcaster m_private_state_broadcaster; // This broadcaster feeds state
                                            // changed events into the private
                                            // state thread's listener.
   Broadcaster m_private_state_control_broadcaster; // This is the control
                                                    // broadcaster, used to

lldb/source/Target/Process.cpp

Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp)
     : Process(target_sp, listener_sp,
               UnixSignals::Create(HostInfo::GetArchitecture())) {
   // This constructor just delegates to the full Process constructor,
   // defaulting to using the Host's UnixSignals.
 }
 
 Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp,
                  const UnixSignalsSP &unix_signals_sp)
-    : ProcessProperties(this), UserID(LLDB_INVALID_PROCESS_ID),
+    : ProcessProperties(this),
       Broadcaster((target_sp->GetDebugger().GetBroadcasterManager()),
                   Process::GetStaticBroadcasterClass().AsCString()),
       m_target_wp(target_sp), m_public_state(eStateUnloaded),
       m_private_state(eStateUnloaded),
       m_private_state_broadcaster(nullptr,
                                   "lldb.process.internal_state_broadcaster"),
       m_private_state_control_broadcaster(
           nullptr, "lldb.process.internal_state_control_broadcaster"),