[lldb] Remove FormattersContainer's name member

[teemperor]

Summary

FormattersContainer currently has an unused m_name member. Usually LLDB allows giving objects names,
but for the FormattersContainer it seems excessive. There are only 4 FormattersContainer variables in LLDB
and they are not usually passed around, so one can always just go up a few frames when debugging to find
out which FormattersContainer you're dealing with.

[mib]

LGTM!

lldb/include/lldb/DataFormatters/FormattersContainer.h

public:
   typedef KeyType MapKeyType;
   typedef std::shared_ptr<ValueType> MapValueType;
   typedef typename BackEndType::ForEachCallback ForEachCallback;
   typedef typename std::shared_ptr<FormattersContainer<KeyType, ValueType>>
       SharedPointer;
 
   friend class TypeCategoryImpl;
 
-  FormattersContainer(std::string name, IFormatChangeListener *lst)
-      : m_format_map(lst), m_name(name) {}
+  FormattersContainer(IFormatChangeListener *lst) : m_format_map(lst) {}
 
   void Add(MapKeyType type, const MapValueType &entry) {
     Add_Impl(std::move(type), entry, static_cast<KeyType *>(nullptr));
   }
 
   bool Delete(ConstString type) {
     return Delete_Impl(type, static_cast<KeyType *>(nullptr));
   }
public:
   void Clear() { m_format_map.Clear(); }
 
   void ForEach(ForEachCallback callback) { m_format_map.ForEach(callback); }
 
   uint32_t GetCount() { return m_format_map.GetCount(); }
 
 protected:
   BackEndType m_format_map;
-  std::string m_name;
 
   FormattersContainer(const FormattersContainer &) = delete;
   const FormattersContainer &operator=(const FormattersContainer &) = delete;
 
   void Add_Impl(MapKeyType type, const MapValueType &entry,
                 RegularExpression *dummy) {
     m_format_map.Add(std::move(type), entry);
   }

lldb/include/lldb/DataFormatters/TypeCategory.h

public:
   typedef typename ExactMatchContainer::SharedPointer ExactMatchContainerSP;
   typedef typename RegexMatchContainer::SharedPointer RegexMatchContainerSP;
 
   typedef
       typename ExactMatchContainer::ForEachCallback ExactMatchForEachCallback;
   typedef
       typename RegexMatchContainer::ForEachCallback RegexMatchForEachCallback;
 
-  FormatterContainerPair(const char *exact_name, const char *regex_name,
-                         IFormatChangeListener *clist)
-      : m_exact_sp(new ExactMatchContainer(std::string(exact_name), clist)),
-        m_regex_sp(new RegexMatchContainer(std::string(regex_name), clist)) {}
+  FormatterContainerPair(IFormatChangeListener *clist)
+      : m_exact_sp(new ExactMatchContainer(clist)),
+        m_regex_sp(new RegexMatchContainer(clist)) {}
 
   ~FormatterContainerPair() = default;
 
   ExactMatchContainerSP GetExactMatch() const { return m_exact_sp; }
 
   RegexMatchContainerSP GetRegexMatch() const { return m_regex_sp; }
 
   uint32_t GetCount() {

lldb/source/DataFormatters/TypeCategory.cpp

 #include "lldb/Target/Language.h"
 
 
 using namespace lldb;
 using namespace lldb_private;
 
 TypeCategoryImpl::TypeCategoryImpl(IFormatChangeListener *clist,
                                    ConstString name)
-    : m_format_cont("format", "regex-format", clist),
-      m_summary_cont("summary", "regex-summary", clist),
-      m_filter_cont("filter", "regex-filter", clist),
-      m_synth_cont("synth", "regex-synth", clist), m_enabled(false),
-      m_change_listener(clist), m_mutex(), m_name(name), m_languages() {}
+    : m_format_cont(clist), m_summary_cont(clist), m_filter_cont(clist),
+      m_synth_cont(clist), m_enabled(false), m_change_listener(clist),
+      m_mutex(), m_name(name), m_languages() {}
 
 static bool IsApplicable(lldb::LanguageType category_lang,
                          lldb::LanguageType valobj_lang) {
   switch (category_lang) {
   // Unless we know better, allow only exact equality.
   default:
     return category_lang == valobj_lang;