[lldb/Interpreter] Make ScriptedProcessInfo more generic

[mib]

Summary

This patch moves the ScriptedProcessInfo class out of the
ScriptedProcess and hoist it as a standalone interpreter class, so it can be
reused with the Scripted Platform.

Signed-off-by: Med Ismail Bennani <[e-mail]>

[JDevlieghere]

lldb/include/lldb/Utility/ScriptedMetadata.h

12–14 ↗

(On Diff #479805)

These are layering violations. Host and Interpreter both depend on Utility. Regardless this class doesn't seem like a good fit for Utility anyway.

[mib]

lldb/include/lldb/Utility/ScriptedMetadata.h

12–14 ↗

(On Diff #479805)

@JDevlieghere Do you think it'd make more sense to have it in the Interpreter directory ?

[mib]

Move class from Utility to Interpreter

[bulbazord]

lldb/include/lldb/Interpreter/ScriptedMetadata.h

9–10

This should be LLDB_INTERPRETER_SCRIPTEDMETADATA_H to be consistent with other classes in Interpreter.

[mib]

Update header guard

[bulbazord]

LGTM

[JDevlieghere]

lldb/include/lldb/Interpreter/ScriptedMetadata.h

37

Why return a copy? Can this be a StringRef?

[mib]

lldb/include/lldb/Interpreter/ScriptedMetadata.h

37

I guess we can return a StringRef but the member type still needs to be std::string to keep ownership.

[mib]

Address @JDevlieghere comment

[JDevlieghere]

LGTM

lldb/include/lldb/Interpreter/ScriptedMetadata.h

+//===-- ScriptedMetadata.h ------------------------------------ -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_PLUGINS_SCRIPTED_METADATA_H
+#define LLDB_SOURCE_PLUGINS_SCRIPTED_METADATA_H
+
+#include "OptionGroupPythonClassWithDict.h"
+
+#include "lldb/Host/Host.h"
+#include "lldb/Host/ProcessLaunchInfo.h"
+#include "lldb/Utility/StructuredData.h"
+
+namespace lldb_private {
+class ScriptedMetadata {
+public:
+  ScriptedMetadata(llvm::StringRef class_name,
+                   StructuredData::DictionarySP dict_sp)
+      : m_class_name(class_name.data()), m_args_sp(dict_sp) {}
+
+  ScriptedMetadata(const ProcessLaunchInfo &launch_info) {
+    m_class_name = launch_info.GetScriptedProcessClassName();
+    m_args_sp = launch_info.GetScriptedProcessDictionarySP();
+  }
+
+  ScriptedMetadata(const OptionGroupPythonClassWithDict &option_group) {
+    auto opt_group = const_cast<OptionGroupPythonClassWithDict &>(option_group);
+    m_class_name = opt_group.GetName();
+    m_args_sp = opt_group.GetStructuredData();
+  }
+
+  std::string GetClassName() const { return m_class_name; }
+  StructuredData::DictionarySP GetArgsSP() const { return m_args_sp; }
+
+private:
+  std::string m_class_name;
+  StructuredData::DictionarySP m_args_sp;
+};
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H

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

 //===-- ScriptedProcess.h ------------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H
 #define LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H
 
+#include "lldb/Interpreter/ScriptedMetadata.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 
 #include "ScriptedThread.h"
 
 #include <mutex>
 
 namespace lldb_private {
-
 class ScriptedProcess : public Process {
-protected:
-  class ScriptedProcessInfo {
-  public:
-    ScriptedProcessInfo(const ProcessLaunchInfo &launch_info) {
-      m_class_name = launch_info.GetScriptedProcessClassName();
-      m_args_sp = launch_info.GetScriptedProcessDictionarySP();
-    }
-
-    std::string GetClassName() const { return m_class_name; }
-    StructuredData::DictionarySP GetArgsSP() const { return m_args_sp; }
-
-  private:
-    std::string m_class_name;
-    StructuredData::DictionarySP m_args_sp;
-  };
-
 public:
   static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
                                         lldb::ListenerSP listener_sp,
                                         const FileSpec *crash_file_path,
                                         bool can_connect);
 
   static void Initialize();
 
public:
 
   lldb_private::StructuredData::ObjectSP
   GetLoadedDynamicLibrariesInfos() override;
 
   lldb_private::StructuredData::DictionarySP GetMetadata() override;
 
 protected:
   ScriptedProcess(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
-                  const ScriptedProcess::ScriptedProcessInfo &launch_info,
-                  Status &error);
+                  const ScriptedMetadata &scripted_metadata, Status &error);
 
   Status DoStop();
 
   void Clear();
 
   bool DoUpdateThreadList(ThreadList &old_thread_list,
                           ThreadList &new_thread_list) override;
 
   Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                MemoryRegionInfo &range_info) override;
 
 private:
   friend class ScriptedThread;
 
   void CheckInterpreterAndScriptObject() const;
   ScriptedProcessInterface &GetInterface() const;
   static bool IsScriptLanguageSupported(lldb::ScriptLanguage language);
 
   // Member variables.
-  const ScriptedProcessInfo m_scripted_process_info;
+  const ScriptedMetadata m_scripted_metadata;
   lldb_private::ScriptInterpreter *m_interpreter = nullptr;
   lldb_private::StructuredData::ObjectSP m_script_object_sp = nullptr;
   //@}
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SCRIPTED_PROCESS_H

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

 #include "lldb/Core/PluginManager.h"
 
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupBoolean.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
+#include "lldb/Interpreter/ScriptedMetadata.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/State.h"
 
 #include <mutex>
 
 LLDB_PLUGIN_DEFINE(ScriptedProcess)

 lldb::ProcessSP ScriptedProcess::CreateInstance(lldb::TargetSP target_sp,
                                                 lldb::ListenerSP listener_sp,
                                                 const FileSpec *file,
                                                 bool can_connect) {
   if (!target_sp ||
       !IsScriptLanguageSupported(target_sp->GetDebugger().GetScriptLanguage()))
     return nullptr;
 
-  Status error;
-  ScriptedProcess::ScriptedProcessInfo scripted_process_info(
-      target_sp->GetProcessLaunchInfo());
+  ScriptedMetadata scripted_metadata(target_sp->GetProcessLaunchInfo());
 
-  auto process_sp = std::shared_ptr<ScriptedProcess>(new ScriptedProcess(
-      target_sp, listener_sp, scripted_process_info, error));
+  Status error;
+  auto process_sp = std::shared_ptr<ScriptedProcess>(
+      new ScriptedProcess(target_sp, listener_sp, scripted_metadata, error));
 
   if (error.Fail() || !process_sp || !process_sp->m_script_object_sp ||
       !process_sp->m_script_object_sp->IsValid()) {
     LLDB_LOGF(GetLog(LLDBLog::Process), "%s", error.AsCString());
     return nullptr;
   }
 
   return process_sp;
 }
 
 bool ScriptedProcess::CanDebug(lldb::TargetSP target_sp,
                                bool plugin_specified_by_name) {
   return true;
 }
 
-ScriptedProcess::ScriptedProcess(
-    lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
-    const ScriptedProcess::ScriptedProcessInfo &scripted_process_info,
+ScriptedProcess::ScriptedProcess(lldb::TargetSP target_sp,
+                                 lldb::ListenerSP listener_sp,
+                                 const ScriptedMetadata &scripted_metadata,
                                  Status &error)
-    : Process(target_sp, listener_sp),
-      m_scripted_process_info(scripted_process_info) {
+    : Process(target_sp, listener_sp), m_scripted_metadata(scripted_metadata) {
 
   if (!target_sp) {
     error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    __FUNCTION__, "Invalid target");
     return;
   }
 
   m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
 
   if (!m_interpreter) {
     error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    __FUNCTION__,
                                    "Debugger has no Script Interpreter");
     return;
   }
 
   ExecutionContext exe_ctx(target_sp, /*get_process=*/false);
 
   StructuredData::GenericSP object_sp = GetInterface().CreatePluginObject(
-      m_scripted_process_info.GetClassName().c_str(), exe_ctx,
-      m_scripted_process_info.GetArgsSP());
+      m_scripted_metadata.GetClassName().c_str(), exe_ctx,
+      m_scripted_metadata.GetArgsSP());
 
   if (!object_sp || !object_sp->IsValid()) {
     error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
                                    __FUNCTION__,
                                    "Failed to create valid script object");
     return;
   }
 

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

if (!class_name || class_name->empty())
           llvm::inconvertibleErrorCode(),
           "Failed to get scripted thread class name.");
     thread_class_name = *class_name;
   }
 
   ExecutionContext exe_ctx(process);
   StructuredData::GenericSP owned_script_object_sp =
       scripted_thread_interface->CreatePluginObject(
-          thread_class_name, exe_ctx,
-          process.m_scripted_process_info.GetArgsSP(), script_object);
+          thread_class_name, exe_ctx, process.m_scripted_metadata.GetArgsSP(),
+          script_object);
 
   if (!owned_script_object_sp)
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Failed to create script object.");
   if (!owned_script_object_sp->IsValid())
     return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                    "Created script object is invalid.");