[lldb/Reproducers] Add instrumentation to SBEnvironment

This class should've been instrumented when it landed. Whether the class
is "highly mutable" or not doesn't affect that.

With this patch TestSBEnvironment.py now passes when replayed.

lldb/source/API/SBEnvironment.cpp

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBEnvironment.h"
+#include "SBReproducerPrivate.h"
 #include "Utils.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/Utility/ConstString.h"
@@ -15,12 +16,14 @@
 using namespace lldb;
 using namespace lldb_private;
 
-/// This class is highly mutable, therefore we don't reproducers.
-
-SBEnvironment::SBEnvironment() : m_opaque_up(new Environment()) {}
+SBEnvironment::SBEnvironment() : m_opaque_up(new Environment()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEnvironment);
+}
 
 SBEnvironment::SBEnvironment(const SBEnvironment &rhs)
-    : m_opaque_up(clone(rhs.m_opaque_up)) {}
+    : m_opaque_up(clone(rhs.m_opaque_up)) {
+  LLDB_RECORD_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &), rhs);
+}
 
 SBEnvironment::SBEnvironment(Environment rhs)
     : m_opaque_up(new Environment(std::move(rhs))) {}
@@ -28,16 +31,24 @@ SBEnvironment::SBEnvironment(Environment rhs)
 SBEnvironment::~SBEnvironment() = default;
 
 const SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) {
+  LLDB_RECORD_METHOD(const lldb::SBEnvironment &,
+                     SBEnvironment, operator=,(const lldb::SBEnvironment &),
+                     rhs);
+
   if (this != &rhs)
     m_opaque_up = clone(rhs.m_opaque_up);
-  return *this;
+  return LLDB_RECORD_RESULT(*this);
 }
 
 size_t SBEnvironment::GetNumValues() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBEnvironment, GetNumValues);
+
   return m_opaque_up->size();
 }
 
 const char *SBEnvironment::Get(const char *name) {
+  LLDB_RECORD_METHOD(const char *, SBEnvironment, Get, (const char *), name);
+
   auto entry = m_opaque_up->find(name);
   if (entry == m_opaque_up->end()) {
     return nullptr;
@@ -46,6 +57,9 @@ const char *SBEnvironment::Get(const char *name) {
 }
 
 const char *SBEnvironment::GetNameAtIndex(size_t index) {
+  LLDB_RECORD_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t),
+                     index);
+
   if (index >= GetNumValues())
     return nullptr;
   return ConstString(std::next(m_opaque_up->begin(), index)->first())
@@ -53,6 +67,9 @@ const char *SBEnvironment::GetNameAtIndex(size_t index) {
 }
 
 const char *SBEnvironment::GetValueAtIndex(size_t index) {
+  LLDB_RECORD_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t),
+                     index);
+
   if (index >= GetNumValues())
     return nullptr;
   return ConstString(std::next(m_opaque_up->begin(), index)->second)
@@ -60,6 +77,10 @@ const char *SBEnvironment::GetValueAtIndex(size_t index) {
 }
 
 bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) {
+  LLDB_RECORD_METHOD(bool, SBEnvironment, Set,
+                     (const char *, const char *, bool), name, value,
+                     overwrite);
+
   if (overwrite) {
     m_opaque_up->insert_or_assign(name, std::string(value));
     return true;
@@ -68,23 +89,33 @@ bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) {
 }
 
 bool SBEnvironment::Unset(const char *name) {
+  LLDB_RECORD_METHOD(bool, SBEnvironment, Unset, (const char *), name);
+
   return m_opaque_up->erase(name);
 }
 
 SBStringList SBEnvironment::GetEntries() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStringList, SBEnvironment, GetEntries);
+
   SBStringList entries;
   for (const auto &KV : *m_opaque_up) {
     entries.AppendString(Environment::compose(KV).c_str());
   }
-  return entries;
+  return LLDB_RECORD_RESULT(entries);
 }
 
 void SBEnvironment::PutEntry(const char *name_and_value) {
+  LLDB_RECORD_METHOD(void, SBEnvironment, PutEntry, (const char *),
+                     name_and_value);
+
   auto split = llvm::StringRef(name_and_value).split('=');
   m_opaque_up->insert_or_assign(split.first.str(), split.second.str());
 }
 
 void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
+  LLDB_RECORD_METHOD(void, SBEnvironment, SetEntries,
+                     (const lldb::SBStringList &, bool), entries, append);
+
   if (!append)
     m_opaque_up->clear();
   for (size_t i = 0; i < entries.GetSize(); i++) {
@@ -93,7 +124,32 @@ void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
 }
 
 void SBEnvironment::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBEnvironment, Clear);
+
   m_opaque_up->clear();
 }
 
 Environment &SBEnvironment::ref() const { return *m_opaque_up; }
+
+namespace lldb_private {
+namespace repro {
+template <> void RegisterMethods<SBEnvironment>(Registry &R) {
+  LLDB_REGISTER_CONSTRUCTOR(SBEnvironment, ());
+  LLDB_REGISTER_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &));
+  LLDB_REGISTER_METHOD(const lldb::SBEnvironment &,
+                       SBEnvironment, operator=,(const lldb::SBEnvironment &));
+  LLDB_REGISTER_METHOD(size_t, SBEnvironment, GetNumValues, ());
+  LLDB_REGISTER_METHOD(const char *, SBEnvironment, Get, (const char *));
+  LLDB_REGISTER_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t));
+  LLDB_REGISTER_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t));
+  LLDB_REGISTER_METHOD(bool, SBEnvironment, Set,
+                       (const char *, const char *, bool));
+  LLDB_REGISTER_METHOD(bool, SBEnvironment, Unset, (const char *));
+  LLDB_REGISTER_METHOD(lldb::SBStringList, SBEnvironment, GetEntries, ());
+  LLDB_REGISTER_METHOD(void, SBEnvironment, PutEntry, (const char *));
+  LLDB_REGISTER_METHOD(void, SBEnvironment, SetEntries,
+                       (const lldb::SBStringList &, bool));
+  LLDB_REGISTER_METHOD(void, SBEnvironment, Clear, ());
+}
+} // namespace repro
+} // namespace lldb_private

lldb/source/API/SBReproducer.cpp

@@ -47,9 +47,9 @@ SBRegistry::SBRegistry() {
   RegisterMethods<SBCommunication>(R);
   RegisterMethods<SBCompileUnit>(R);
   RegisterMethods<SBData>(R);
-  RegisterMethods<SBInputReader>(R);
   RegisterMethods<SBDebugger>(R);
   RegisterMethods<SBDeclaration>(R);
+  RegisterMethods<SBEnvironment>(R);
   RegisterMethods<SBError>(R);
   RegisterMethods<SBEvent>(R);
   RegisterMethods<SBExecutionContext>(R);
@@ -60,6 +60,7 @@ SBRegistry::SBRegistry() {
   RegisterMethods<SBFrame>(R);
   RegisterMethods<SBFunction>(R);
   RegisterMethods<SBHostOS>(R);
+  RegisterMethods<SBInputReader>(R);
   RegisterMethods<SBInstruction>(R);
   RegisterMethods<SBInstructionList>(R);
   RegisterMethods<SBLanguageRuntime>(R);
@@ -70,9 +71,9 @@ SBRegistry::SBRegistry() {
   RegisterMethods<SBMemoryRegionInfoList>(R);
   RegisterMethods<SBModule>(R);
   RegisterMethods<SBModuleSpec>(R);
+  RegisterMethods<SBPlatform>(R);
   RegisterMethods<SBPlatformConnectOptions>(R);
   RegisterMethods<SBPlatformShellCommand>(R);
-  RegisterMethods<SBPlatform>(R);
   RegisterMethods<SBProcess>(R);
   RegisterMethods<SBProcessInfo>(R);
   RegisterMethods<SBQueue>(R);
@@ -97,8 +98,8 @@ SBRegistry::SBRegistry() {
   RegisterMethods<SBTypeFilter>(R);
   RegisterMethods<SBTypeFormat>(R);
   RegisterMethods<SBTypeNameSpecifier>(R);
-  RegisterMethods<SBTypeSummaryOptions>(R);
   RegisterMethods<SBTypeSummary>(R);
+  RegisterMethods<SBTypeSummaryOptions>(R);
   RegisterMethods<SBTypeSynthetic>(R);
   RegisterMethods<SBUnixSignals>(R);
   RegisterMethods<SBValue>(R);