Revert "[lldb] Move ScriptedProcess private state update to implementation"

This reverts commit 3c33d72e7fa83beb8a9b39fb3b8ecf4ee00c697d.

lldb/examples/python/scripted_process/scripted_process.py

@@ -160,24 +160,30 @@ class ScriptedProcess(metaclass=ABCMeta):
         """
         return lldb.SBError()
 
-    def resume(self, should_stop=True):
+    def resume(self):
         """ Simulate the scripted process resume.
 
-        Args:
-            should_stop (bool): If True, resume will also 
-
         Returns:
             lldb.SBError: An `lldb.SBError` with error code 0.
         """
-        process = self.target.GetProcess()
-        if not process:
-            error = lldb.SBError()
-            error.SetErrorString("Invalid process.")
-            return error
+        return lldb.SBError()
 
-        process.ForceScriptedState(lldb.eStateRunning);
-        if (should_stop):
-            process.ForceScriptedState(lldb.eStateStopped);
+    @abstractmethod
+    def should_stop(self):
+        """ Check if the scripted process plugin should produce the stop event.
+
+        Returns:
+            bool: True if scripted process should broadcast a stop event.
+                  False otherwise.
+        """
+        pass
+
+    def stop(self):
+        """ Trigger the scripted process stop.
+
+        Returns:
+            lldb.SBError: An `lldb.SBError` with error code 0.
+        """
         return lldb.SBError()
 
     @abstractmethod

lldb/include/lldb/Interpreter/ScriptedProcessInterface.h

@@ -38,6 +38,10 @@ public:
 
   virtual Status Resume() { return Status("ScriptedProcess did not resume"); }
 
+  virtual bool ShouldStop() { return true; }
+
+  virtual Status Stop() { return Status("ScriptedProcess did not stop"); }
+
   virtual std::optional<MemoryRegionInfo>
   GetMemoryRegionContainingAddress(lldb::addr_t address, Status &error) {
     error.SetErrorString("ScriptedProcess have no memory region.");

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

@@ -187,6 +187,8 @@ Status ScriptedProcess::DoResume() {
   if (resume) {
     LLDB_LOGF(log, "ScriptedProcess::%s sending resume", __FUNCTION__);
 
+    SetPrivateState(eStateRunning);
+    SetPrivateState(eStateStopped);
     error = GetInterface().Resume();
   }
 
@@ -221,6 +223,19 @@ void ScriptedProcess::DidAttach(ArchSpec &process_arch) {
   process_arch = GetArchitecture();
 }
 
+Status ScriptedProcess::DoStop() {
+  Log *log = GetLog(LLDBLog::Process);
+
+  if (GetInterface().ShouldStop()) {
+    SetPrivateState(eStateStopped);
+    LLDB_LOGF(log, "ScriptedProcess::%s Immediate stop", __FUNCTION__);
+    return {};
+  }
+
+  LLDB_LOGF(log, "ScriptedProcess::%s Delayed stop", __FUNCTION__);
+  return GetInterface().Stop();
+}
+
 Status ScriptedProcess::DoDestroy() { return Status(); }
 
 bool ScriptedProcess::IsAlive() { return GetInterface().IsAlive(); }

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

@@ -94,6 +94,8 @@ protected:
   ScriptedProcess(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
                   const ScriptedMetadata &scripted_metadata, Status &error);
 
+  Status DoStop();
+
   void Clear();
 
   bool DoUpdateThreadList(ThreadList &old_thread_list,

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

@@ -201,7 +201,6 @@ template <> struct PythonFormat<short> : PassthroughFormat<short, 'h'> {};
 template <>
 struct PythonFormat<unsigned short> : PassthroughFormat<unsigned short, 'H'> {};
 template <> struct PythonFormat<int> : PassthroughFormat<int, 'i'> {};
-template <> struct PythonFormat<bool> : PassthroughFormat<bool, 'p'> {};
 template <>
 struct PythonFormat<unsigned int> : PassthroughFormat<unsigned int, 'I'> {};
 template <> struct PythonFormat<long> : PassthroughFormat<long, 'l'> {};

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedProcessPythonInterface.cpp

@@ -80,8 +80,21 @@ Status ScriptedProcessPythonInterface::Launch() {
 }
 
 Status ScriptedProcessPythonInterface::Resume() {
-  // When calling ScriptedProcess.Resume from lldb we should always stop.
-  return GetStatusFromMethod("resume", /*should_stop=*/true);
+  return GetStatusFromMethod("resume");
+}
+
+bool ScriptedProcessPythonInterface::ShouldStop() {
+  Status error;
+  StructuredData::ObjectSP obj = Dispatch("is_alive", error);
+
+  if (!CheckStructuredDataObject(LLVM_PRETTY_FUNCTION, obj, error))
+    return {};
+
+  return obj->GetBooleanValue();
+}
+
+Status ScriptedProcessPythonInterface::Stop() {
+  return GetStatusFromMethod("stop");
 }
 
 std::optional<MemoryRegionInfo>

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedProcessPythonInterface.h

@@ -37,6 +37,10 @@ public:
 
   Status Resume() override;
 
+  bool ShouldStop() override;
+
+  Status Stop() override;
+
   std::optional<MemoryRegionInfo>
   GetMemoryRegionContainingAddress(lldb::addr_t address,
                                    Status &error) override;

lldb/source/Plugins/ScriptInterpreter/Python/ScriptedPythonInterface.h

@@ -113,11 +113,6 @@ protected:
     return {object};
   }
 
-  python::PythonObject Transform(bool arg) {
-    // Boolean arguments need to be turned into python objects.
-    return python::PythonBoolean(arg);
-  }
-
   python::PythonObject Transform(Status arg) {
     return python::ToSWIGWrapper(arg);
   }
@@ -146,15 +141,6 @@ protected:
     original_arg = ExtractValueFromPythonObject<T>(transformed_arg, error);
   }
 
-  template <>
-  void ReverseTransform(bool &original_arg,
-                        python::PythonObject transformed_arg, Status &error) {
-    python::PythonBoolean boolean_arg = python::PythonBoolean(
-        python::PyRefType::Borrowed, transformed_arg.get());
-    if (boolean_arg.IsValid())
-      original_arg = boolean_arg.GetValue();
-  }
-
   template <std::size_t... I, typename... Args>
   auto TransformTuple(const std::tuple<Args...> &args,
                       std::index_sequence<I...>) {