1 files changed, 102 insertions, 18 deletions

diff --git a/source/API/SBTypeSynthetic.cpp b/source/API/SBTypeSynthetic.cpp
index 750d917e67f15..df6fce1269f09 100644
--- a/source/API/SBTypeSynthetic.cpp
+++ b/source/API/SBTypeSynthetic.cpp
@@ -1,14 +1,14 @@
 //===-- SBTypeSynthetic.cpp -----------------------------------------*- C++
 //-*-===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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 "lldb/API/SBTypeSynthetic.h"
+#include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBStream.h"
 
@@ -17,34 +17,55 @@
 using namespace lldb;
 using namespace lldb_private;
 
-#ifndef LLDB_DISABLE_PYTHON
-
-SBTypeSynthetic::SBTypeSynthetic() : m_opaque_sp() {}
+SBTypeSynthetic::SBTypeSynthetic() : m_opaque_sp() {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeSynthetic);
+}
 
 SBTypeSynthetic SBTypeSynthetic::CreateWithClassName(const char *data,
                                                      uint32_t options) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+                            CreateWithClassName, (const char *, uint32_t), data,
+                            options);
+
   if (!data || data[0] == 0)
-    return SBTypeSynthetic();
-  return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
-      new ScriptedSyntheticChildren(options, data, "")));
+    return LLDB_RECORD_RESULT(SBTypeSynthetic());
+  return LLDB_RECORD_RESULT(SBTypeSynthetic(ScriptedSyntheticChildrenSP(
+      new ScriptedSyntheticChildren(options, data, ""))));
 }
 
 SBTypeSynthetic SBTypeSynthetic::CreateWithScriptCode(const char *data,
                                                       uint32_t options) {
+  LLDB_RECORD_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+                            CreateWithScriptCode, (const char *, uint32_t),
+                            data, options);
+
   if (!data || data[0] == 0)
-    return SBTypeSynthetic();
-  return SBTypeSynthetic(ScriptedSyntheticChildrenSP(
-      new ScriptedSyntheticChildren(options, "", data)));
+    return LLDB_RECORD_RESULT(SBTypeSynthetic());
+  return LLDB_RECORD_RESULT(SBTypeSynthetic(ScriptedSyntheticChildrenSP(
+      new ScriptedSyntheticChildren(options, "", data))));
 }
 
 SBTypeSynthetic::SBTypeSynthetic(const lldb::SBTypeSynthetic &rhs)
-    : m_opaque_sp(rhs.m_opaque_sp) {}
+    : m_opaque_sp(rhs.m_opaque_sp) {
+  LLDB_RECORD_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &),
+                          rhs);
+}
 
 SBTypeSynthetic::~SBTypeSynthetic() {}
 
-bool SBTypeSynthetic::IsValid() const { return m_opaque_sp.get() != NULL; }
+bool SBTypeSynthetic::IsValid() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, IsValid);
+  return this->operator bool();
+}
+SBTypeSynthetic::operator bool() const {
+  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeSynthetic, operator bool);
+
+  return m_opaque_sp.get() != nullptr;
+}
 
 bool SBTypeSynthetic::IsClassCode() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassCode);
+
   if (!IsValid())
     return false;
   const char *code = m_opaque_sp->GetPythonCode();
@@ -52,14 +73,18 @@ bool SBTypeSynthetic::IsClassCode() {
 }
 
 bool SBTypeSynthetic::IsClassName() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBTypeSynthetic, IsClassName);
+
   if (!IsValid())
     return false;
   return !IsClassCode();
 }
 
 const char *SBTypeSynthetic::GetData() {
+  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBTypeSynthetic, GetData);
+
   if (!IsValid())
-    return NULL;
+    return nullptr;
   if (IsClassCode())
     return m_opaque_sp->GetPythonCode();
   else
@@ -67,22 +92,30 @@ const char *SBTypeSynthetic::GetData() {
 }
 
 void SBTypeSynthetic::SetClassName(const char *data) {
+  LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassName, (const char *), data);
+
   if (IsValid() && data && *data)
     m_opaque_sp->SetPythonClassName(data);
 }
 
 void SBTypeSynthetic::SetClassCode(const char *data) {
+  LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *), data);
+
   if (IsValid() && data && *data)
     m_opaque_sp->SetPythonCode(data);
 }
 
 uint32_t SBTypeSynthetic::GetOptions() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeSynthetic, GetOptions);
+
   if (!IsValid())
     return lldb::eTypeOptionNone;
   return m_opaque_sp->GetOptions();
 }
 
 void SBTypeSynthetic::SetOptions(uint32_t value) {
+  LLDB_RECORD_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t), value);
+
   if (!CopyOnWrite_Impl())
     return;
   m_opaque_sp->SetOptions(value);
@@ -90,6 +123,10 @@ void SBTypeSynthetic::SetOptions(uint32_t value) {
 
 bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
                                      lldb::DescriptionLevel description_level) {
+  LLDB_RECORD_METHOD(bool, SBTypeSynthetic, GetDescription,
+                     (lldb::SBStream &, lldb::DescriptionLevel), description,
+                     description_level);
+
   if (m_opaque_sp) {
     description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
     return true;
@@ -99,19 +136,29 @@ bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
 
 lldb::SBTypeSynthetic &SBTypeSynthetic::
 operator=(const lldb::SBTypeSynthetic &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic &,
+                     SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &),
+                     rhs);
+
   if (this != &rhs) {
     m_opaque_sp = rhs.m_opaque_sp;
   }
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
+  LLDB_RECORD_METHOD(
+      bool, SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp == rhs.m_opaque_sp;
 }
 
 bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
+  LLDB_RECORD_METHOD(bool, SBTypeSynthetic, IsEqualTo,
+                     (lldb::SBTypeSynthetic &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
 
@@ -128,6 +175,9 @@ bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
 }
 
 bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) {
+  LLDB_RECORD_METHOD(
+      bool, SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &), rhs);
+
   if (!IsValid())
     return !rhs.IsValid();
   return m_opaque_sp != rhs.m_opaque_sp;
@@ -161,4 +211,38 @@ bool SBTypeSynthetic::CopyOnWrite_Impl() {
   return true;
 }
 
-#endif // LLDB_DISABLE_PYTHON
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBTypeSynthetic>(Registry &R) {
+  LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, ());
+  LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+                              CreateWithClassName, (const char *, uint32_t));
+  LLDB_REGISTER_STATIC_METHOD(lldb::SBTypeSynthetic, SBTypeSynthetic,
+                              CreateWithScriptCode, (const char *, uint32_t));
+  LLDB_REGISTER_CONSTRUCTOR(SBTypeSynthetic, (const lldb::SBTypeSynthetic &));
+  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, IsValid, ());
+  LLDB_REGISTER_METHOD_CONST(bool, SBTypeSynthetic, operator bool, ());
+  LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassCode, ());
+  LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsClassName, ());
+  LLDB_REGISTER_METHOD(const char *, SBTypeSynthetic, GetData, ());
+  LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassName, (const char *));
+  LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetClassCode, (const char *));
+  LLDB_REGISTER_METHOD(uint32_t, SBTypeSynthetic, GetOptions, ());
+  LLDB_REGISTER_METHOD(void, SBTypeSynthetic, SetOptions, (uint32_t));
+  LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, GetDescription,
+                       (lldb::SBStream &, lldb::DescriptionLevel));
+  LLDB_REGISTER_METHOD(
+      lldb::SBTypeSynthetic &,
+      SBTypeSynthetic, operator=,(const lldb::SBTypeSynthetic &));
+  LLDB_REGISTER_METHOD(bool,
+                       SBTypeSynthetic, operator==,(lldb::SBTypeSynthetic &));
+  LLDB_REGISTER_METHOD(bool, SBTypeSynthetic, IsEqualTo,
+                       (lldb::SBTypeSynthetic &));
+  LLDB_REGISTER_METHOD(bool,
+                       SBTypeSynthetic, operator!=,(lldb::SBTypeSynthetic &));
+}
+
+}
+}