[lldb/Reproducers] Simplify LLDB_RECORD macros

[JDevlieghere]

Summary

Redefine the LLDB_RECORD macros in terms of a common uber-macro to reduce code duplication across them.

[JDevlieghere]

Add a comment

[labath]

This looks even better than I hoped. I think this is a worthwhile simplification even without the followup patches. Just a couple of questions inline...

lldb/include/lldb/Utility/ReproducerInstrumentation.h

117–135

Could you merge these two in a similar way as well (not with the method macros, just with themselves)? I know that the constructors could be implemented as a function in the other patch, but I have a feeling it will be pretty confusing if two very similar functionalities were implemented in completely different ways...

137

idea: Should we standardize the name of the inner class and drop the Method argument?

768–771

Why the void overload? It looks like the templated version would work just fine for void too...

[JDevlieghere]

Address Pavel's code review feedback

[labath]

Very nice.

lldb/include/lldb/Utility/ReproducerInstrumentation.h

 
 #define LLDB_REGISTER_CHAR_PTR_REDIRECT_CONST(Result, Class, Method)           \
   R.Register(&invoke<Result (Class::*)(char *, size_t)                         \
                          const>::method_const<(&Class::Method)>::doit,         \
              &char_ptr_redirect<Result (Class::*)(                             \
                  char *, size_t) const>::method_const<(&Class::Method)>::doit, \
              #Result, #Class, #Method, "(char*, size_t");
 
 #define LLDB_RECORD_CONSTRUCTOR(Class, Signature, ...)                         \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
                                           stringify_args(__VA_ARGS__));        \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
                      &lldb_private::repro::construct<Class Signature>::doit,   \
                      __VA_ARGS__);                                             \
     _recorder.RecordResult(this, false);                                       \
   }
 
 #define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)                                 \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);               \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
                      &lldb_private::repro::construct<Class()>::doit);          \
     _recorder.RecordResult(this, false);                                       \
   }
 
-#define LLDB_RECORD_METHOD(Result, Class, Method, Signature, ...)              \
+#define LLDB_RECORD_(Method, T1, T2, ...)                                      \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(*this, __VA_ARGS__)); \
+                                          stringify_args(__VA_ARGS__));        \
   if (lldb_private::repro::InstrumentationData _data =                         \
           LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
     _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::invoke<Result(                      \
-                         Class::*) Signature>::method<(&Class::Method)>::doit, \
-                     this, __VA_ARGS__);                                       \
+                     &lldb_private::repro::invoke<T1>::Method<T2>::doit,       \
+                     __VA_ARGS__);                                             \
   }
 
+#define LLDB_RECORD_METHOD(Result, Class, Method, Signature, ...)              \
+  LLDB_RECORD_(method, Result(Class::*) Signature, (&Class::Method), this,     \
+               __VA_ARGS__)
+
 #define LLDB_RECORD_METHOD_CONST(Result, Class, Method, Signature, ...)        \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(*this, __VA_ARGS__)); \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(                                                          \
-        _data.GetSerializer(), _data.GetRegistry(),                            \
-        &lldb_private::repro::invoke<Result(                                   \
-            Class::*) Signature const>::method_const<(&Class::Method)>::doit,  \
-        this, __VA_ARGS__);                                                    \
-  }
+  LLDB_RECORD_(method_const, Result(Class::*) Signature const,                 \
+               (&Class::Method), this, __VA_ARGS__)
 
 #define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)                      \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(*this));              \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     &lldb_private::repro::invoke<Result (                     \
-                         Class::*)()>::method<(&Class::Method)>::doit,         \
-                     this);                                                    \
-  }
+  LLDB_RECORD_(method, Result (Class::*)(), (&Class::Method), this)
 
 #define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)                \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(*this));              \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(                                                          \
-        _data.GetSerializer(), _data.GetRegistry(),                            \
-        &lldb_private::repro::invoke<Result (                                  \
-            Class::*)() const>::method_const<(&Class::Method)>::doit,          \
-        this);                                                                 \
-  }
+  LLDB_RECORD_(method_const, Result (Class::*)() const, (&Class::Method), this)
 
 #define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature, ...)       \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
-                                          stringify_args(__VA_ARGS__));        \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(                                                          \
-        _data.GetSerializer(), _data.GetRegistry(),                            \
-        lldb_private::repro::invoke<Result(*) Signature>::method_static<(      \
-            &Class::Method)>::doit,                                            \
-        __VA_ARGS__);                                                          \
-  }
+  LLDB_RECORD_(method_static, Result(*) Signature, (&Class::Method),           \
+               __VA_ARGS__)
 
 #define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method)               \
-  lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION);               \
-  if (lldb_private::repro::InstrumentationData _data =                         \
-          LLDB_GET_INSTRUMENTATION_DATA()) {                                   \
-    _recorder.Record(_data.GetSerializer(), _data.GetRegistry(),               \
-                     lldb_private::repro::invoke<Result (*)()>::method_static< \
-                         (&Class::Method)>::doit);                             \
-  }
+  LLDB_RECORD_(method_static, Result (*)(), (&Class::Method),                  \
+               lldb_private::repro::EmptyArg())
 
 #define LLDB_RECORD_RESULT(Result) _recorder.RecordResult(Result, true);
 
 /// The LLDB_RECORD_DUMMY macro is special because it doesn't actually record
 /// anything. It's used to track API boundaries when we cannot record for
 /// technical reasons.
 #define LLDB_RECORD_DUMMY(Result, Class, Method, Signature, ...)               \
   lldb_private::repro::Recorder _recorder(LLVM_PRETTY_FUNCTION,                \
public:
 
   operator bool() { return m_serializer != nullptr && m_registry != nullptr; }
 
 private:
   Serializer *m_serializer;
   Registry *m_registry;
 };
 
+struct EmptyArg {};
+
 /// RAII object that records function invocations and their return value.
 ///
 /// API calls are only captured when the API boundary is crossed. Once we're in
 /// the API layer, and another API function is called, it doesn't need to be
 /// recorded.
 ///
 /// When a call is recored, its result is always recorded as well, even if the
 /// function returns a void. For functions that return by value, RecordResult
 /// should be used. Otherwise a sentinel value (0) will be serialized.
 ///
 /// Because of the functional overlap between logging and recording API calls,
 /// this class is also used for logging.
 class Recorder {
 public:
   Recorder(llvm::StringRef pretty_func = {}, std::string &&pretty_args = {});
   ~Recorder();
 
+  template <typename Result>
+  void Record(Serializer &serializer, Registry &registry, Result (*f)(),
+              const EmptyArg &arg) {
+    Record(serializer, registry, f);
+  }
+
+  void Record(Serializer &serializer, Registry &registry, void (*f)(),
+              const EmptyArg &arg) {
+    Record(serializer, registry, f);
+  }
+
   /// Records a single function call.
   template <typename Result, typename... FArgs, typename... RArgs>
   void Record(Serializer &serializer, Registry &registry, Result (*f)(FArgs...),
               const RArgs &... args) {
     m_serializer = &serializer;
     if (!ShouldCapture())
       return;
 
#endif
   Result RecordResult(Result &&r, bool update_boundary) {
     // When recording the result from the LLDB_RECORD_RESULT macro, we need to
     // update the boundary so we capture the copy constructor. However, when
     // called to record the this pointer of the (copy) constructor, the
     // boundary should not be toggled, because it is called from the
     // LLDB_RECORD_CONSTRUCTOR macro, which might be followed by other API
     // calls.
     if (update_boundary)
       UpdateBoundary();
     if (m_serializer && ShouldCapture()) {
       assert(!m_result_recorded);
       m_serializer->SerializeAll(r);
       m_result_recorded = true;
     }
     return std::forward<Result>(r);
   }
 
 private:
   void UpdateBoundary() {
     if (m_local_boundary)