Replace redundant code in FormatManager and FormatCache with templates (NFC)

This is a preparatory patch for an upcoming bugfix.

FormatManager and friends have four identical implementations of many
accessor functions to deal with the four types of shared pointers in
the FormatCache. This patch replaces these implementations with
templates. While this patch drastically reduces the amount of source
code and its maintainablity, it doesn't actually improve code
size. I'd argue, this is still an improvement.

rdar://problem/57756763

Differential Revision: https://reviews.llvm.org/D71231

1 files changed, 53 insertions, 118 deletions

diff --git a/lldb/source/DataFormatters/FormatCache.cpp b/lldb/source/DataFormatters/FormatCache.cpp
index 7e328cb0dac..0876673cfa8 100644
--- a/lldb/source/DataFormatters/FormatCache.cpp
+++ b/lldb/source/DataFormatters/FormatCache.cpp
@@ -17,46 +17,7 @@ using namespace lldb_private;
 
 FormatCache::Entry::Entry()
     : m_format_cached(false), m_summary_cached(false),
-      m_synthetic_cached(false), m_validator_cached(false), m_format_sp(),
-      m_summary_sp(), m_synthetic_sp(), m_validator_sp() {}
-
-FormatCache::Entry::Entry(lldb::TypeFormatImplSP format_sp)
-    : m_summary_cached(false), m_synthetic_cached(false),
-      m_validator_cached(false), m_summary_sp(), m_synthetic_sp(),
-      m_validator_sp() {
-  SetFormat(format_sp);
-}
-
-FormatCache::Entry::Entry(lldb::TypeSummaryImplSP summary_sp)
-    : m_format_cached(false), m_synthetic_cached(false),
-      m_validator_cached(false), m_format_sp(), m_synthetic_sp(),
-      m_validator_sp() {
-  SetSummary(summary_sp);
-}
-
-FormatCache::Entry::Entry(lldb::SyntheticChildrenSP synthetic_sp)
-    : m_format_cached(false), m_summary_cached(false),
-      m_validator_cached(false), m_format_sp(), m_summary_sp(),
-      m_validator_sp() {
-  SetSynthetic(synthetic_sp);
-}
-
-FormatCache::Entry::Entry(lldb::TypeValidatorImplSP validator_sp)
-    : m_format_cached(false), m_summary_cached(false),
-      m_synthetic_cached(false), m_format_sp(), m_summary_sp(),
-      m_synthetic_sp() {
-  SetValidator(validator_sp);
-}
-
-FormatCache::Entry::Entry(lldb::TypeFormatImplSP format_sp,
-                          lldb::TypeSummaryImplSP summary_sp,
-                          lldb::SyntheticChildrenSP synthetic_sp,
-                          lldb::TypeValidatorImplSP validator_sp) {
-  SetFormat(format_sp);
-  SetSummary(summary_sp);
-  SetSynthetic(synthetic_sp);
-  SetValidator(validator_sp);
-}
+      m_synthetic_cached(false), m_validator_cached(false) {}
 
 bool FormatCache::Entry::IsFormatCached() { return m_format_cached; }
 
@@ -66,36 +27,38 @@ bool FormatCache::Entry::IsSyntheticCached() { return m_synthetic_cached; }
 
 bool FormatCache::Entry::IsValidatorCached() { return m_validator_cached; }
 
-lldb::TypeFormatImplSP FormatCache::Entry::GetFormat() { return m_format_sp; }
+void FormatCache::Entry::Get(lldb::TypeFormatImplSP &retval) {
+  retval = m_format_sp;
+}
 
-lldb::TypeSummaryImplSP FormatCache::Entry::GetSummary() {
-  return m_summary_sp;
+void FormatCache::Entry::Get(lldb::TypeSummaryImplSP &retval) {
+  retval = m_summary_sp;
 }
 
-lldb::SyntheticChildrenSP FormatCache::Entry::GetSynthetic() {
-  return m_synthetic_sp;
+void FormatCache::Entry::Get(lldb::SyntheticChildrenSP &retval) {
+  retval = m_synthetic_sp;
 }
 
-lldb::TypeValidatorImplSP FormatCache::Entry::GetValidator() {
-  return m_validator_sp;
+void FormatCache::Entry::Get(lldb::TypeValidatorImplSP &retval) {
+  retval = m_validator_sp;
 }
 
-void FormatCache::Entry::SetFormat(lldb::TypeFormatImplSP format_sp) {
+void FormatCache::Entry::Set(lldb::TypeFormatImplSP format_sp) {
   m_format_cached = true;
   m_format_sp = format_sp;
 }
 
-void FormatCache::Entry::SetSummary(lldb::TypeSummaryImplSP summary_sp) {
+void FormatCache::Entry::Set(lldb::TypeSummaryImplSP summary_sp) {
   m_summary_cached = true;
   m_summary_sp = summary_sp;
 }
 
-void FormatCache::Entry::SetSynthetic(lldb::SyntheticChildrenSP synthetic_sp) {
+void FormatCache::Entry::Set(lldb::SyntheticChildrenSP synthetic_sp) {
   m_synthetic_cached = true;
   m_synthetic_sp = synthetic_sp;
 }
 
-void FormatCache::Entry::SetValidator(lldb::TypeValidatorImplSP validator_sp) {
+void FormatCache::Entry::Set(lldb::TypeValidatorImplSP validator_sp) {
   m_validator_cached = true;
   m_validator_sp = validator_sp;
 }
@@ -117,100 +80,72 @@ FormatCache::Entry &FormatCache::GetEntry(ConstString type) {
   return m_map[type];
 }
 
-bool FormatCache::GetFormat(ConstString type,
-                            lldb::TypeFormatImplSP &format_sp) {
-  std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  auto entry = GetEntry(type);
-  if (entry.IsFormatCached()) {
-#ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_hits++;
-#endif
-    format_sp = entry.GetFormat();
-    return true;
-  }
-#ifdef LLDB_CONFIGURATION_DEBUG
-  m_cache_misses++;
-#endif
-  format_sp.reset();
-  return false;
+template<> bool FormatCache::Entry::IsCached<lldb::TypeFormatImplSP>() {
+  return IsFormatCached();
 }
-
-bool FormatCache::GetSummary(ConstString type,
-                             lldb::TypeSummaryImplSP &summary_sp) {
-  std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  auto entry = GetEntry(type);
-  if (entry.IsSummaryCached()) {
-#ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_hits++;
-#endif
-    summary_sp = entry.GetSummary();
-    return true;
-  }
-#ifdef LLDB_CONFIGURATION_DEBUG
-  m_cache_misses++;
-#endif
-  summary_sp.reset();
-  return false;
+template<> bool FormatCache::Entry::IsCached<lldb::TypeSummaryImplSP> () {
+  return IsSummaryCached();
 }
-
-bool FormatCache::GetSynthetic(ConstString type,
-                               lldb::SyntheticChildrenSP &synthetic_sp) {
-  std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  auto entry = GetEntry(type);
-  if (entry.IsSyntheticCached()) {
-#ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_hits++;
-#endif
-    synthetic_sp = entry.GetSynthetic();
-    return true;
-  }
-#ifdef LLDB_CONFIGURATION_DEBUG
-  m_cache_misses++;
-#endif
-  synthetic_sp.reset();
-  return false;
+template<> bool FormatCache::Entry::IsCached<lldb::SyntheticChildrenSP>() {
+  return IsSyntheticCached();
+}
+template<> bool FormatCache::Entry::IsCached<lldb::TypeValidatorImplSP>() {
+  return IsValidatorCached();
 }
 
-bool FormatCache::GetValidator(ConstString type,
-                               lldb::TypeValidatorImplSP &validator_sp) {
+template <typename ImplSP>
+bool FormatCache::Get(ConstString type, ImplSP &format_impl_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   auto entry = GetEntry(type);
-  if (entry.IsValidatorCached()) {
+  if (entry.IsCached<ImplSP>()) {
 #ifdef LLDB_CONFIGURATION_DEBUG
     m_cache_hits++;
 #endif
-    validator_sp = entry.GetValidator();
+    entry.Get(format_impl_sp);
     return true;
   }
 #ifdef LLDB_CONFIGURATION_DEBUG
   m_cache_misses++;
 #endif
-  validator_sp.reset();
+  format_impl_sp.reset();
   return false;
 }
 
-void FormatCache::SetFormat(ConstString type,
-                            lldb::TypeFormatImplSP &format_sp) {
+/// Explicit instantiations for the four types.
+/// \{
+template bool
+FormatCache::Get<lldb::TypeValidatorImplSP>(ConstString,
+                                            lldb::TypeValidatorImplSP &);
+template bool
+FormatCache::Get<lldb::TypeFormatImplSP>(ConstString, lldb::TypeFormatImplSP &);
+template bool
+FormatCache::Get<lldb::TypeSummaryImplSP>(ConstString,
+                                          lldb::TypeSummaryImplSP &);
+template bool
+FormatCache::Get<lldb::SyntheticChildrenSP>(ConstString,
+                                            lldb::SyntheticChildrenSP &);
+/// \}
+
+void FormatCache::Set(ConstString type, lldb::TypeFormatImplSP &format_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  GetEntry(type).SetFormat(format_sp);
+  GetEntry(type).Set(format_sp);
 }
 
-void FormatCache::SetSummary(ConstString type,
-                             lldb::TypeSummaryImplSP &summary_sp) {
+void FormatCache::Set(ConstString type, lldb::TypeSummaryImplSP &summary_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  GetEntry(type).SetSummary(summary_sp);
+  GetEntry(type).Set(summary_sp);
 }
 
-void FormatCache::SetSynthetic(ConstString type,
-                               lldb::SyntheticChildrenSP &synthetic_sp) {
+void FormatCache::Set(ConstString type,
+                      lldb::SyntheticChildrenSP &synthetic_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  GetEntry(type).SetSynthetic(synthetic_sp);
+  GetEntry(type).Set(synthetic_sp);
 }
 
-void FormatCache::SetValidator(ConstString type,
-                               lldb::TypeValidatorImplSP &validator_sp) {
+void FormatCache::Set(ConstString type,
+                      lldb::TypeValidatorImplSP &validator_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  GetEntry(type).SetValidator(validator_sp);
+  GetEntry(type).Set(validator_sp);
 }
 
 void FormatCache::Clear() {