[lldb] Fix lua build after 27b6a4e63afe

[bulbazord]

Summary

This applies the same trick for Lua that I did for python in
27b6a4e63afe.

[mib]

We've already discussed that offline but I really think there should be a ScriptInterpreter SWIGBridge plugin and that would have all the method the Python and Lua SWIGBridge have in common, so the SB classes won't have to be specialized for every scripting language.

[bulbazord]

So, I agree that we should definitely unify this or else we end up doing this for every scripting language that we add support for. That being said, I think this is actually better than what we had before because now we're not exposing lldb private details in the public interface. There is a TODO comment in SWIGPythonBridge.h already for cleaning this up when we have a moment... I don't want to block this patch unless we're ok reverting the previous one, and I'd preferably not revert that one...

[mib]

Let's fix the Lua build failures first

[JDevlieghere]

I have enabled Lua testing on the incremental bot on GreenDragon (https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/). This has always been the intention (note how the job mentions "Python 3 and Lua 5.3") but wasn't enabled until earlier today.

[kparzysz]

It works now. Thanks!

lldb/bindings/lua/lua-wrapper.swig

 %header %{
 
 template <typename T> void PushSBClass(lua_State * L, T * obj);
 
 // This function is called from Lua::CallBreakpointCallback
-llvm::Expected<bool> lldb_private::LLDBSwigLuaBreakpointCallbackFunction(
+llvm::Expected<bool>
+lldb_private::lua::SWIGBridge::LLDBSwigLuaBreakpointCallbackFunction(
     lua_State * L, lldb::StackFrameSP stop_frame_sp,
     lldb::BreakpointLocationSP bp_loc_sp,
     const StructuredDataImpl &extra_args_impl) {
   lldb::SBFrame sb_frame(stop_frame_sp);
   lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp);
   int nargs = 2;
 
   lldb::SBStructuredData extra_args(extra_args_impl);
lldb_private::lua::SWIGBridge::LLDBSwigLuaBreakpointCallbackFunction(
   // Boolean return from the callback
   bool stop = lua_toboolean(L, -1);
   lua_pop(L, 1);
 
   return stop;
 }
 
 // This function is called from Lua::CallWatchpointCallback
-llvm::Expected<bool> lldb_private::LLDBSwigLuaWatchpointCallbackFunction(
+llvm::Expected<bool>
+lldb_private::lua::SWIGBridge::LLDBSwigLuaWatchpointCallbackFunction(
     lua_State * L, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp) {
   lldb::SBFrame sb_frame(stop_frame_sp);
   lldb::SBWatchpoint sb_wp(wp_sp);
   int nargs = 2;
 
   // Push the Lua wrappers
   PushSBClass(L, &sb_frame);
   PushSBClass(L, &sb_wp);

lldb/include/lldb/API/SBBreakpointLocation.h

 
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBDefines.h"
 
 namespace lldb_private {
 namespace python {
 class SWIGBridge;
 }
+namespace lua {
+class SWIGBridge;
+}
 } // namespace lldb_private
 
 namespace lldb {
 
 class LLDB_API SBBreakpointLocation {
 public:
   SBBreakpointLocation();
 
#endif
   bool IsResolved();
 
   bool GetDescription(lldb::SBStream &description, DescriptionLevel level);
 
   SBBreakpoint GetBreakpoint();
 
 protected:
   friend class lldb_private::python::SWIGBridge;
+  friend class lldb_private::lua::SWIGBridge;
   SBBreakpointLocation(const lldb::BreakpointLocationSP &break_loc_sp);
 
 private:
   friend class SBBreakpoint;
   friend class SBBreakpointCallbackBaton;
 
   void SetLocation(const lldb::BreakpointLocationSP &break_loc_sp);
   BreakpointLocationSP GetSP() const;
 
   lldb::BreakpointLocationWP m_opaque_wp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBBREAKPOINTLOCATION_H

lldb/include/lldb/API/SBFrame.h

 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBValueList.h"
 
 namespace lldb_private {
 namespace python {
 class SWIGBridge;
 }
+namespace lua {
+class SWIGBridge;
+}
 } // namespace lldb_private
 
 namespace lldb {
 
 class LLDB_API SBFrame {
 public:
   SBFrame();
 

 protected:
   friend class SBBlock;
   friend class SBExecutionContext;
   friend class SBInstruction;
   friend class SBThread;
   friend class SBValue;
 
   friend class lldb_private::python::SWIGBridge;
+  friend class lldb_private::lua::SWIGBridge;
 
   SBFrame(const lldb::StackFrameSP &lldb_object_sp);
 
   lldb::StackFrameSP GetFrameSP() const;
 
   void SetFrameSP(const lldb::StackFrameSP &lldb_object_sp);
 
   lldb::ExecutionContextRefSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBFRAME_H

lldb/include/lldb/API/SBStructuredData.h

 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBModule.h"
 
 namespace lldb_private {
 namespace python {
 class SWIGBridge;
 }
+namespace lua {
+class SWIGBridge;
+}
 } // namespace lldb_private
 
 namespace lldb {
 
 class SBStructuredData {
 public:
   SBStructuredData();
 
protected:
   friend class SBProcess;
   friend class SBThread;
   friend class SBThreadPlan;
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
   friend class SBTrace;
   friend class lldb_private::python::SWIGBridge;
+  friend class lldb_private::lua::SWIGBridge;
 
   SBStructuredData(const lldb_private::StructuredDataImpl &impl);
 
   SBStructuredData(const lldb::EventSP &event_sp);
 
   StructuredDataImplUP m_impl_up;
 };
 } // namespace lldb
 
 #endif // LLDB_API_SBSTRUCTUREDDATA_H

lldb/include/lldb/API/SBWatchpoint.h

 //===-- SBWatchpoint.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_API_SBWATCHPOINT_H
 #define LLDB_API_SBWATCHPOINT_H
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBType.h"
 
 namespace lldb_private {
-namespace ptyhon {
+namespace python {
+class SWIGBridge;
+}
+namespace lua {
 class SWIGBridge;
 }
 } // namespace lldb_private
 
 namespace lldb {
 
 class LLDB_API SBWatchpoint {
 public:
public:
   const char *GetWatchSpec();
 
   bool IsWatchingReads();
 
   bool IsWatchingWrites();
 
 protected:
   friend class lldb_private::python::SWIGBridge;
+  friend class lldb_private::lua::SWIGBridge;
 
   SBWatchpoint(const lldb::WatchpointSP &wp_sp);
 
   lldb::WatchpointSP GetSP() const;
 
   void SetSP(const lldb::WatchpointSP &sp);
 
 private:

lldb/source/Plugins/ScriptInterpreter/Lua/Lua.cpp

 llvm::Expected<bool>
 Lua::CallBreakpointCallback(void *baton, lldb::StackFrameSP stop_frame_sp,
                             lldb::BreakpointLocationSP bp_loc_sp,
                             StructuredData::ObjectSP extra_args_sp) {
 
   lua_pushlightuserdata(m_lua_state, baton);
   lua_gettable(m_lua_state, LUA_REGISTRYINDEX);
   StructuredDataImpl extra_args_impl(std::move(extra_args_sp));
-  return LLDBSwigLuaBreakpointCallbackFunction(m_lua_state, stop_frame_sp,
-                                               bp_loc_sp, extra_args_impl);
+  return lua::SWIGBridge::LLDBSwigLuaBreakpointCallbackFunction(
+      m_lua_state, stop_frame_sp, bp_loc_sp, extra_args_impl);
 }
 
 llvm::Error Lua::RegisterWatchpointCallback(void *baton, const char *body) {
   lua_pushlightuserdata(m_lua_state, baton);
   const char *fmt_str = "return function(frame, wp, ...) {0} end";
   std::string func_str = llvm::formatv(fmt_str, body).str();
   if (luaL_dostring(m_lua_state, func_str.c_str()) != LUA_OK) {
     llvm::Error e = llvm::make_error<llvm::StringError>(
         llvm::formatv("{0}", lua_tostring(m_lua_state, -1)),
         llvm::inconvertibleErrorCode());
     // Pop error message from the stack.
     lua_pop(m_lua_state, 2);
     return e;
   }
   lua_settable(m_lua_state, LUA_REGISTRYINDEX);
   return llvm::Error::success();
 }
 
 llvm::Expected<bool>
 Lua::CallWatchpointCallback(void *baton, lldb::StackFrameSP stop_frame_sp,
                             lldb::WatchpointSP wp_sp) {
 
   lua_pushlightuserdata(m_lua_state, baton);
   lua_gettable(m_lua_state, LUA_REGISTRYINDEX);
-  return LLDBSwigLuaWatchpointCallbackFunction(m_lua_state, stop_frame_sp,
-                                               wp_sp);
+  return lua::SWIGBridge::LLDBSwigLuaWatchpointCallbackFunction(
+      m_lua_state, stop_frame_sp, wp_sp);
 }
 
 llvm::Error Lua::CheckSyntax(llvm::StringRef buffer) {
   int error =
       luaL_loadbuffer(m_lua_state, buffer.data(), buffer.size(), "buffer");
   if (error == LUA_OK) {
     // Pop buffer
     lua_pop(m_lua_state, 1);

lldb/source/Plugins/ScriptInterpreter/Lua/SWIGLuaBridge.h

 #define LLDB_PLUGINS_SCRIPTINTERPRETER_LUA_SWIGLUABRIDGE_H
 
 #include "lldb/lldb-forward.h"
 #include "lua.hpp"
 #include "llvm/Support/Error.h"
 
 namespace lldb_private {
 
-llvm::Expected<bool> LLDBSwigLuaBreakpointCallbackFunction(
+namespace lua {
+
+class SWIGBridge {
+public:
+  static llvm::Expected<bool> LLDBSwigLuaBreakpointCallbackFunction(
       lua_State *L, lldb::StackFrameSP stop_frame_sp,
       lldb::BreakpointLocationSP bp_loc_sp,
       const StructuredDataImpl &extra_args_impl);
 
-llvm::Expected<bool> LLDBSwigLuaWatchpointCallbackFunction(
+  static llvm::Expected<bool> LLDBSwigLuaWatchpointCallbackFunction(
       lua_State *L, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp);
+};
+
+} // namespace lua
 
 } // namespace lldb_private
 
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_LUA_SWIGLUABRIDGE_H

lldb/unittests/ScriptInterpreter/Lua/LuaTests.cpp

 //===-- LuaTests.cpp ------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/ScriptInterpreter/Lua/Lua.h"
 #include "Plugins/ScriptInterpreter/Lua/SWIGLuaBridge.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 extern "C" int luaopen_lldb(lua_State *L) { return 0; }
 
-llvm::Expected<bool> lldb_private::LLDBSwigLuaBreakpointCallbackFunction(
+llvm::Expected<bool>
+lldb_private::lua::SWIGBridge::LLDBSwigLuaBreakpointCallbackFunction(
     lua_State *L, lldb::StackFrameSP stop_frame_sp,
     lldb::BreakpointLocationSP bp_loc_sp,
     const StructuredDataImpl &extra_args_impl) {
   return false;
 }
 
-llvm::Expected<bool> lldb_private::LLDBSwigLuaWatchpointCallbackFunction(
+llvm::Expected<bool>
+lldb_private::lua::SWIGBridge::LLDBSwigLuaWatchpointCallbackFunction(
     lua_State *L, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp) {
   return false;
 }
 
 TEST(LuaTest, RunValid) {
   Lua lua;
   llvm::Error error = lua.Run("foo = 1");
   EXPECT_FALSE(static_cast<bool>(error));