[lldb/Interpreter] Make `ScriptedInterface::ErrorWithMessage` static (NFC)

[mib]

Summary

This patch changes the ScriptedInterface::ErrorWithMessage method to
make it static which makes it easier to call.

The patch also updates its various call sites to reflect this change.

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

[mib]

Rebase

[mib]

Format

[JDevlieghere]

LGTM

lldb/include/lldb/Interpreter/ScriptedInterface.h

public:
   virtual ~ScriptedInterface() = default;
 
   virtual StructuredData::GenericSP
   CreatePluginObject(llvm::StringRef class_name, ExecutionContext &exe_ctx,
                      StructuredData::DictionarySP args_sp,
                      StructuredData::Generic *script_obj = nullptr) = 0;
 
   template <typename Ret>
-  Ret ErrorWithMessage(llvm::StringRef caller_name, llvm::StringRef error_msg,
-                       Status &error,
+  static Ret ErrorWithMessage(llvm::StringRef caller_name,
+                              llvm::StringRef error_msg, Status &error,
                               uint32_t log_caterogy = LIBLLDB_LOG_PROCESS) {
     LLDB_LOGF(GetLogIfAllCategoriesSet(log_caterogy), "%s ERROR = %s",
               caller_name.data(), error_msg.data());
     error.SetErrorString(llvm::Twine(caller_name + llvm::Twine(" ERROR = ") +
                                      llvm::Twine(error_msg))
                              .str());
     return {};
   }
 

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

bool ScriptedProcess::IsAlive() {
   if (m_interpreter && m_script_object_sp)
     return GetInterface().IsAlive();
   return false;
 }
 
 size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                                      Status &error) {
   if (!m_interpreter)
-    return GetInterface().ErrorWithMessage<size_t>(LLVM_PRETTY_FUNCTION,
-                                                   "No interpreter.", error);
+    return ScriptedInterface::ErrorWithMessage<size_t>(
+        LLVM_PRETTY_FUNCTION, "No interpreter.", error);
 
   lldb::DataExtractorSP data_extractor_sp =
       GetInterface().ReadMemoryAtAddress(addr, size, error);
 
   if (!data_extractor_sp || !data_extractor_sp->GetByteSize() || error.Fail())
     return 0;
 
   offset_t bytes_copied = data_extractor_sp->CopyByteOrderedData(
       0, data_extractor_sp->GetByteSize(), buf, size, GetByteOrder());
 
   if (!bytes_copied || bytes_copied == LLDB_INVALID_OFFSET)
-    return GetInterface().ErrorWithMessage<size_t>(
+    return ScriptedInterface::ErrorWithMessage<size_t>(
         LLVM_PRETTY_FUNCTION, "Failed to copy read memory to buffer.", error);
 
   return size;
 }
 
 ArchSpec ScriptedProcess::GetArchitecture() {
   return GetTarget().GetArchitecture();
 }
bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list,
 
   CheckInterpreterAndScriptObject();
   m_thread_plans.ClearThreadCache();
 
   Status error;
   ScriptLanguage language = m_interpreter->GetLanguage();
 
   if (language != eScriptLanguagePython)
-    return GetInterface().ErrorWithMessage<bool>(
+    return ScriptedInterface::ErrorWithMessage<bool>(
         LLVM_PRETTY_FUNCTION,
         llvm::Twine("ScriptInterpreter language (" +
                     llvm::Twine(m_interpreter->LanguageToString(language)) +
                     llvm::Twine(") not supported."))
             .str(),
         error);
 
   StructuredData::DictionarySP thread_info_sp = GetInterface().GetThreadsInfo();
 
   if (!thread_info_sp)
-    return GetInterface().ErrorWithMessage<bool>(
+    return ScriptedInterface::ErrorWithMessage<bool>(
         LLVM_PRETTY_FUNCTION,
         "Couldn't fetch thread list from Scripted Process.", error);
 
   auto create_scripted_thread =
       [this, &old_thread_list, &error,
        &new_thread_list](ConstString key, StructuredData::Object *val) -> bool {
     if (!val)
-      return GetInterface().ErrorWithMessage<bool>(
+      return ScriptedInterface::ErrorWithMessage<bool>(
           LLVM_PRETTY_FUNCTION, "Invalid thread info object", error);
 
     lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
     if (!llvm::to_integer(key.AsCString(), tid))
-      return GetInterface().ErrorWithMessage<bool>(LLVM_PRETTY_FUNCTION,
-                                                   "Invalid thread id", error);
+      return ScriptedInterface::ErrorWithMessage<bool>(
+          LLVM_PRETTY_FUNCTION, "Invalid thread id", error);
 
     if (ThreadSP thread_sp =
             old_thread_list.FindThreadByID(tid, false /*=can_update*/)) {
       // If the thread was already in the old_thread_list,
       // just add it back to the new_thread_list.
       new_thread_list.AddThread(thread_sp);
       return true;
     }
 
     lldb::ThreadSP thread_sp =
         ScriptedThread::Create(*this, error, val->GetAsGeneric());
 
     if (!thread_sp || error.Fail())
-      return GetInterface().ErrorWithMessage<bool>(LLVM_PRETTY_FUNCTION,
-                                                   error.AsCString(), error);
+      return ScriptedInterface::ErrorWithMessage<bool>(
+          LLVM_PRETTY_FUNCTION, error.AsCString(), error);
 
     RegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
     if (!reg_ctx_sp)
-      return GetInterface().ErrorWithMessage<bool>(
+      return ScriptedInterface::ErrorWithMessage<bool>(
           LLVM_PRETTY_FUNCTION,
           llvm::Twine("Invalid Register Context for thread " +
                       llvm::Twine(key.AsCString()))
               .str(),
           error);
 
     new_thread_list.AddThread(thread_sp);
 

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

if (!process.IsValid()) {
     return nullptr;
   }
 
   process.CheckInterpreterAndScriptObject();
 
   auto scripted_thread_interface =
       process.GetInterface().CreateScriptedThreadInterface();
   if (!scripted_thread_interface)
-    return process.GetInterface()
-        .ErrorWithMessage<std::shared_ptr<ScriptedThread>>(
-            LLVM_PRETTY_FUNCTION, "Failed to create scripted thread interface.",
-            error);
+    return ScriptedInterface::ErrorWithMessage<std::shared_ptr<ScriptedThread>>(
 
   llvm::Optional<std::string> class_name =
       process.GetInterface().GetScriptedThreadPluginName();
   if (!class_name || class_name->empty())
-    return process.GetInterface()
-        .ErrorWithMessage<std::shared_ptr<ScriptedThread>>(
-            LLVM_PRETTY_FUNCTION, "Failed to get scripted thread class name.",
-            error);
+    return ScriptedInterface::ErrorWithMessage<std::shared_ptr<ScriptedThread>>(
 
   ExecutionContext exe_ctx(process);
   StructuredData::GenericSP owned_script_object_sp =
       scripted_thread_interface->CreatePluginObject(
           class_name->c_str(), exe_ctx,
           process.m_scripted_process_info.GetArgsSP(), script_object);
 
   if (!owned_script_object_sp)
-    return process.GetInterface()
-        .ErrorWithMessage<std::shared_ptr<ScriptedThread>>(
-            LLVM_PRETTY_FUNCTION, "Failed to create script object", error);
+    return ScriptedInterface::ErrorWithMessage<std::shared_ptr<ScriptedThread>>(
   if (!owned_script_object_sp->IsValid())
-    return process.GetInterface()
-        .ErrorWithMessage<std::shared_ptr<ScriptedThread>>(
-            LLVM_PRETTY_FUNCTION, "Created script object is invalid", error);
+    return ScriptedInterface::ErrorWithMessage<std::shared_ptr<ScriptedThread>>(
 
   lldb::tid_t tid = scripted_thread_interface->GetThreadID();
 
   return std::make_shared<ScriptedThread>(process, scripted_thread_interface,
                                           error, tid, owned_script_object_sp);
 }
 
 ScriptedThread::ScriptedThread(ScriptedProcess &process,