Modernize std::type_info* usage in containers with std::type_index

Introduce operator<< for std::type_index for logging output
Utilize std::unordered_map inside llheteromap, llinitparam, llregistry
Remove unused Comparator template parameter from LLRegistry

18 files changed, 99 insertions, 139 deletions

diff --git a/indra/llcommon/llheteromap.cpp b/indra/llcommon/llheteromap.cpp
index 823bea7a3c..03dd7856b6 100644
--- a/indra/llcommon/llheteromap.cpp
+++ b/indra/llcommon/llheteromap.cpp
@@ -27,6 +27,6 @@ LLHeteroMap::~LLHeteroMap()
         // pair.second is the std::pair; pair.second.first is the void*;
         // pair.second.second points to the deleter function
         (pair.second.second)(pair.second.first);
-        pair.second.first = NULL;
+        pair.second.first = nullptr;
     }
 }
diff --git a/indra/llcommon/llheteromap.h b/indra/llcommon/llheteromap.h
index d8e6fefb17..211dfaae83 100644
--- a/indra/llcommon/llheteromap.h
+++ b/indra/llcommon/llheteromap.h
@@ -12,9 +12,10 @@
 #if ! defined(LL_LLHETEROMAP_H)
 #define LL_LLHETEROMAP_H
 
+#include <typeindex>
 #include <typeinfo>
 #include <utility>                  // std::pair
-#include <map>
+#include <unordered_map>
 
 /**
  * LLHeteroMap addresses an odd requirement. Usually when you want to put
@@ -43,7 +44,7 @@ public:
         // Look up map entry by typeid(T). We don't simply use mMap[typeid(T)]
         // because that requires default-constructing T on every lookup. For
         // some kinds of T, that could be expensive.
-        TypeMap::iterator found = mMap.find(&typeid(T));
+        TypeMap::iterator found = mMap.find(typeid(T));
         if (found == mMap.end())
         {
             // Didn't find typeid(T). Create an entry. Because we're storing
@@ -52,8 +53,8 @@ public:
             void* ptr = new T();
             void (*dlfn)(void*) = &deleter<T>;
             std::pair<TypeMap::iterator, bool> inserted =
-                mMap.insert(TypeMap::value_type(&typeid(T),
-                    TypeMap::mapped_type(ptr, dlfn)));
+                mMap.emplace(typeid(T),
+                    TypeMap::mapped_type(ptr, dlfn));
             // Okay, now that we have an entry, claim we found it.
             found = inserted.first;
         }
@@ -71,23 +72,9 @@ private:
         delete static_cast<T*>(p);
     }
 
-    // Comparing two std::type_info* values is tricky, because the standard
-    // does not guarantee that there will be only one type_info instance for a
-    // given type. In other words, &typeid(A) in one part of the program may
-    // not always equal &typeid(A) in some other part. Use special comparator.
-    struct type_info_ptr_comp
-    {
-        bool operator()(const std::type_info* lhs, const std::type_info* rhs) const
-        {
-            return lhs->before(*rhs);
-        }
-    };
-
-    // What we actually store is a map from std::type_info (permitting lookup
+    // What we actually store is a map from std::type_index (permitting lookup
     // by object type) to a void* pointer to the object PLUS its deleter.
-    typedef std::map<
-        const std::type_info*, std::pair<void*, void (*)(void*)>,
-        type_info_ptr_comp>
+    typedef std::unordered_map<std::type_index, std::pair<void*, void (*)(void*)>>
     TypeMap;
     TypeMap mMap;
 };
diff --git a/indra/llcommon/llinitparam.h b/indra/llcommon/llinitparam.h
index b01ea0bfb1..b220afadfc 100644
--- a/indra/llcommon/llinitparam.h
+++ b/indra/llcommon/llinitparam.h
@@ -34,7 +34,6 @@
 #include <list>
 #include <unordered_map>
 #include <boost/function.hpp>
-#include <boost/unordered_map.hpp>
 
 #include "llerror.h"
 #include "llstl.h"
@@ -267,7 +266,7 @@ namespace LLInitParam
     private:
         struct Inaccessable{};
     public:
-        typedef std::map<std::string, T> value_name_map_t;
+        typedef std::unordered_map<std::string, T> value_name_map_t;
         typedef Inaccessable name_t;
         typedef TypeValues<T> type_value_t;
         typedef ParamValue<typename LLTypeTags::Sorted<T>::value_t> param_value_t;
@@ -294,7 +293,7 @@ namespace LLInitParam
 
         static std::vector<std::string>* getPossibleValues()
         {
-            return NULL;
+            return nullptr;
         }
 
         void assignNamedValue(const Inaccessable& name)
@@ -310,7 +309,7 @@ namespace LLInitParam
             return param_value_t::getValue();
         }
 
-        static value_name_map_t* getValueNames() {return NULL;}
+        static value_name_map_t* getValueNames() { return nullptr; }
     };
 
     // helper class to implement name value lookups
@@ -321,7 +320,7 @@ namespace LLInitParam
     {
         typedef TypeValuesHelper<T, DERIVED_TYPE, IS_SPECIALIZED> self_t;
     public:
-        typedef typename std::map<std::string, T> value_name_map_t;
+        typedef typename std::unordered_map<std::string, T> value_name_map_t;
         typedef std::string name_t;
         typedef self_t type_value_t;
         typedef ParamValue<typename LLTypeTags::Sorted<T>::value_t> param_value_t;
@@ -497,9 +496,9 @@ namespace LLInitParam
         typedef bool (*parser_write_func_t)(Parser& parser, const void*, name_stack_t&);
         typedef std::function<void (name_stack_t&, S32, S32, const possible_values_t*)>   parser_inspect_func_t;
 
-        typedef std::map<const std::type_info*, parser_read_func_t>     parser_read_func_map_t;
-        typedef std::map<const std::type_info*, parser_write_func_t>    parser_write_func_map_t;
-        typedef std::map<const std::type_info*, parser_inspect_func_t>  parser_inspect_func_map_t;
+        typedef std::unordered_map<std::type_index, parser_read_func_t>           parser_read_func_map_t;
+        typedef std::unordered_map<std::type_index, parser_write_func_t>          parser_write_func_map_t;
+        typedef std::unordered_map<std::type_index, parser_inspect_func_t>        parser_inspect_func_map_t;
 
     public:
 
@@ -514,7 +513,7 @@ namespace LLInitParam
 
         template <typename T> bool readValue(T& param, typename std::enable_if_t<!std::is_enum_v<T>>* dummy = 0)
         {
-            parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(&typeid(T));
+            parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(typeid(T));
             if (found_it != mParserReadFuncs->end())
             {
                 return found_it->second(*this, (void*)&param);
@@ -525,14 +524,14 @@ namespace LLInitParam
 
         template <typename T> bool readValue(T& param, typename std::enable_if_t<std::is_enum_v<T> >* dummy = 0)
         {
-            parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(&typeid(T));
+            parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(typeid(T));
             if (found_it != mParserReadFuncs->end())
             {
                 return found_it->second(*this, (void*)&param);
             }
             else
             {
-                found_it = mParserReadFuncs->find(&typeid(S32));
+                found_it = mParserReadFuncs->find(typeid(S32));
                 if (found_it != mParserReadFuncs->end())
                 {
                     S32 int_value;
@@ -546,7 +545,7 @@ namespace LLInitParam
 
         template <typename T> bool writeValue(const T& param, name_stack_t& name_stack)
         {
-            parser_write_func_map_t::iterator found_it = mParserWriteFuncs->find(&typeid(T));
+            parser_write_func_map_t::iterator found_it = mParserWriteFuncs->find(typeid(T));
             if (found_it != mParserWriteFuncs->end())
             {
                 return found_it->second(*this, (const void*)&param, name_stack);
@@ -557,7 +556,7 @@ namespace LLInitParam
         // dispatch inspection to registered inspection functions, for each parameter in a param block
         template <typename T> bool inspectValue(name_stack_t& name_stack, S32 min_count, S32 max_count, const possible_values_t* possible_values)
         {
-            parser_inspect_func_map_t::iterator found_it = mParserInspectFuncs->find(&typeid(T));
+            parser_inspect_func_map_t::iterator found_it = mParserInspectFuncs->find(typeid(T));
             if (found_it != mParserInspectFuncs->end())
             {
                 found_it->second(name_stack, min_count, max_count, possible_values);
@@ -574,16 +573,16 @@ namespace LLInitParam
 
     protected:
         template <typename T>
-        void registerParserFuncs(parser_read_func_t read_func, parser_write_func_t write_func = NULL)
+        void registerParserFuncs(parser_read_func_t read_func, parser_write_func_t write_func = nullptr)
         {
-            mParserReadFuncs->insert(std::make_pair(&typeid(T), read_func));
-            mParserWriteFuncs->insert(std::make_pair(&typeid(T), write_func));
+            mParserReadFuncs->emplace(typeid(T), read_func);
+            mParserWriteFuncs->emplace(typeid(T), write_func);
         }
 
         template <typename T>
         void registerInspectFunc(parser_inspect_func_t inspect_func)
         {
-            mParserInspectFuncs->insert(std::make_pair(&typeid(T), inspect_func));
+            mParserInspectFuncs->emplace(typeid(T), inspect_func);
         }
 
         bool                mParseSilently;
@@ -614,7 +613,7 @@ namespace LLInitParam
     {
         struct UserData
         {
-            virtual ~UserData() {}
+            virtual ~UserData() = default;
         };
 
         typedef bool(*merge_func_t)(Param&, const Param&, bool);
@@ -665,7 +664,7 @@ namespace LLInitParam
         void aggregateBlockData(BlockDescriptor& src_block_data);
         void addParam(ParamDescriptorPtr param, const char* name);
 
-        typedef boost::unordered_map<const std::string, ParamDescriptorPtr>                     param_map_t;
+        typedef std::unordered_map<std::string, ParamDescriptorPtr, ll::string_hash, std::equal_to<>> param_map_t;
         typedef std::vector<ParamDescriptorPtr>                                                 param_list_t;
         typedef std::list<ParamDescriptorPtr>                                                   all_params_list_t;
         typedef std::vector<std::pair<param_handle_t, ParamDescriptor::validation_func_t> >     param_validation_list_t;
@@ -679,38 +678,26 @@ namespace LLInitParam
         class BaseBlock*                mCurrentBlockPtr;       // pointer to block currently being constructed
     };
 
-        //TODO: implement in terms of owned_ptr
-        template<typename T>
+    // TODO: implement in terms of owned_ptr
+    template<typename T>
     class LazyValue
-        {
-        public:
-        LazyValue()
-                : mPtr(NULL)
-            {}
+    {
+    public:
+        LazyValue() = default;
 
-        ~LazyValue()
-            {
-                delete mPtr;
-            }
+        ~LazyValue() { delete mPtr; }
 
-        LazyValue(const T& value)
-            {
-            mPtr = new T(value);
-        }
+        LazyValue(const T& value) { mPtr = new T(value); }
 
-        LazyValue(const LazyValue& other)
-        :   mPtr(NULL)
-                {
-            *this = other;
-                }
+        LazyValue(const LazyValue& other) : mPtr(nullptr) { *this = other; }
 
-        LazyValue& operator = (const LazyValue& other)
-                {
+        LazyValue& operator=(const LazyValue& other)
+        {
             if (!other.mPtr)
             {
                 delete mPtr;
-                    mPtr = NULL;
-                }
+                mPtr = nullptr;
+            }
             else
             {
                 if (!mPtr)
@@ -721,23 +708,21 @@ namespace LLInitParam
                 {
                     *mPtr = *(other.mPtr);
                 }
-                }
-                return *this;
             }
+            return *this;
+        }
 
         bool operator==(const LazyValue& other) const
         {
-            if (empty() || other.empty()) return false;
+            if (empty() || other.empty())
+                return false;
             return *mPtr == *other.mPtr;
         }
 
-            bool empty() const
-            {
-                return mPtr == NULL;
-            }
+        bool empty() const { return mPtr == nullptr; }
 
-            void set(const T& other)
-            {
+        void set(const T& other)
+        {
             if (!mPtr)
             {
                 mPtr = new T(other);
@@ -748,36 +733,26 @@ namespace LLInitParam
             }
         }
 
-            const T& get() const
-            {
-            return *ensureInstance();
-            }
+        const T& get() const { return *ensureInstance(); }
 
-            T& get()
-            {
-            return *ensureInstance();
-        }
+        T& get() { return *ensureInstance(); }
 
-        operator const T&() const
-        {
-            return get();
-            }
+        operator const T&() const { return get(); }
 
-        private:
-            // lazily allocate an instance of T
-            T* ensureInstance() const
+    private:
+        // lazily allocate an instance of T
+        T* ensureInstance() const
+        {
+            if (mPtr == nullptr)
             {
-                if (mPtr == NULL)
-                {
-                    mPtr = new T();
-                }
-                return mPtr;
+                mPtr = new T();
             }
+            return mPtr;
+        }
 
-        private:
-
-            mutable T* mPtr;
-        };
+    private:
+        mutable T* mPtr = nullptr;
+    };
 
     // root class of all parameter blocks
 
@@ -864,7 +839,7 @@ namespace LLInitParam
             mParamProvided(false)
         {}
 
-        virtual ~BaseBlock() {}
+        virtual ~BaseBlock() = default;
         bool submitValue(Parser::name_stack_t& name_stack, Parser& p, bool silent=false);
 
         param_handle_t getHandleFromParam(const Param* param) const;
diff --git a/indra/llcommon/llregistry.h b/indra/llcommon/llregistry.h
index 35335e1213..92f8ae3245 100644
--- a/indra/llcommon/llregistry.h
+++ b/indra/llcommon/llregistry.h
@@ -32,21 +32,11 @@
 #include "llsingleton.h"
 #include "llstl.h"
 
-template <typename T>
-struct LLRegistryDefaultComparator
-{
-    bool operator()(const T& lhs, const T& rhs) const
-    {
-        using std::less;
-        return less<T>()(lhs, rhs);
-    }
-};
-
-template <typename KEY, typename VALUE, typename COMPARATOR = LLRegistryDefaultComparator<KEY> >
+template <typename KEY, typename VALUE>
 class LLRegistry
 {
 public:
-    typedef LLRegistry<KEY, VALUE, COMPARATOR>      registry_t;
+    typedef LLRegistry<KEY, VALUE>      registry_t;
     typedef const KEY&                              ref_const_key_t;
     typedef const VALUE&                            ref_const_value_t;
     typedef const VALUE*                            ptr_const_value_t;
@@ -54,9 +44,9 @@ public:
 
     class Registrar
     {
-        friend class LLRegistry<KEY, VALUE, COMPARATOR>;
+        friend class LLRegistry<KEY, VALUE>;
     public:
-        typedef std::map<KEY, VALUE, COMPARATOR> registry_map_t;
+        typedef std::map<KEY, VALUE> registry_map_t;
 
         bool add(ref_const_key_t key, ref_const_value_t value)
         {
@@ -234,9 +224,9 @@ private:
     Registrar       mDefaultRegistrar;
 };
 
-template <typename KEY, typename VALUE, typename DERIVED_TYPE, typename COMPARATOR = LLRegistryDefaultComparator<KEY> >
+template <typename KEY, typename VALUE, typename DERIVED_TYPE>
 class LLRegistrySingleton
-    :   public LLRegistry<KEY, VALUE, COMPARATOR>,
+    :   public LLRegistry<KEY, VALUE>,
         public LLSingleton<DERIVED_TYPE>
 {
     // This LLRegistrySingleton doesn't use LLSINGLETON(LLRegistrySingleton)
@@ -244,7 +234,7 @@ class LLRegistrySingleton
     // LLRegistrySingleton. So each concrete subclass needs
     // LLSINGLETON(whatever) -- not this intermediate base class.
 public:
-    typedef LLRegistry<KEY, VALUE, COMPARATOR>      registry_t;
+    typedef LLRegistry<KEY, VALUE>      registry_t;
     typedef const KEY&                              ref_const_key_t;
     typedef const VALUE&                            ref_const_value_t;
     typedef VALUE*                                  ptr_value_t;
@@ -309,7 +299,7 @@ public:
     };
 
     // convenience functions
-    typedef typename LLRegistry<KEY, VALUE, COMPARATOR>::Registrar& ref_registrar_t;
+    typedef typename LLRegistry<KEY, VALUE>::Registrar& ref_registrar_t;
     static ref_registrar_t currentRegistrar()
     {
         return singleton_t::instance().registry_t::currentRegistrar();
diff --git a/indra/llcommon/llstl.h b/indra/llcommon/llstl.h
index f8a468a132..7a1c7caf82 100644
--- a/indra/llcommon/llstl.h
+++ b/indra/llcommon/llstl.h
@@ -34,6 +34,7 @@
 #include <vector>
 #include <list>
 #include <set>
+#include <typeindex>
 #include <typeinfo>
 
 #ifdef LL_LINUX
@@ -718,4 +719,11 @@ namespace ll
     };
 } // namespace ll
 
+// Specialize ostream for std::type_index to allow log output
+inline std::ostream& operator<<(std::ostream& s, std::type_index type)
+{
+    s << type.name();
+    return s;
+}
+
 #endif // LL_LLSTL_H
diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
index 52a5e3dbd6..c60253e7fe 100644
--- a/indra/llui/llfloater.cpp
+++ b/indra/llui/llfloater.cpp
@@ -239,7 +239,7 @@ void LLFloater::initClass()
 }
 
 // defaults for floater param block pulled from widgets/floater.xml
-static LLWidgetNameRegistry::StaticRegistrar sRegisterFloaterParams(&typeid(LLFloater::Params), "floater");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterFloaterParams(typeid(LLFloater::Params), "floater");
 
 LLFloater::LLFloater(const LLSD& key, const LLFloater::Params& p)
 :   LLPanel(),  // intentionally do not pass params here, see initFromParams
diff --git a/indra/llui/llradiogroup.cpp b/indra/llui/llradiogroup.cpp
index 2aff434612..1dbd9f5b0c 100644
--- a/indra/llui/llradiogroup.cpp
+++ b/indra/llui/llradiogroup.cpp
@@ -67,7 +67,7 @@ protected:
 
     LLSD mPayload;  // stores data that this item represents in the radio group
 };
-static LLWidgetNameRegistry::StaticRegistrar register_radio_item(&typeid(LLRadioGroup::ItemParams), "radio_item");
+static LLWidgetNameRegistry::StaticRegistrar register_radio_item(typeid(LLRadioGroup::ItemParams), "radio_item");
 
 LLRadioGroup::Params::Params()
 :   allow_deselect("allow_deselect"),
diff --git a/indra/llui/llrngwriter.cpp b/indra/llui/llrngwriter.cpp
index 1b4008cff2..5b0d2315c1 100644
--- a/indra/llui/llrngwriter.cpp
+++ b/indra/llui/llrngwriter.cpp
@@ -94,7 +94,7 @@ void LLRNGWriter::addDefinition(const std::string& type_name, const LLInitParam:
     block.inspectBlock(*this);
 
     // add includes for all possible children
-    const std::type_info* type = *LLWidgetTypeRegistry::instance().getValue(type_name);
+    const std::type_index& type = *LLWidgetTypeRegistry::instance().getValue(type_name);
     const widget_registry_t* widget_registryp = LLChildRegistryRegistry::instance().getValue(type);
 
     // add include declarations for all valid children
diff --git a/indra/llui/llscrolllistcolumn.cpp b/indra/llui/llscrolllistcolumn.cpp
index a4510d1fc2..b5ba466750 100644
--- a/indra/llui/llscrolllistcolumn.cpp
+++ b/indra/llui/llscrolllistcolumn.cpp
@@ -39,7 +39,7 @@
 const S32 MIN_COLUMN_WIDTH = 20;
 
 // defaults for LLScrollColumnHeader param block pulled from widgets/scroll_column_header.xml
-static LLWidgetNameRegistry::StaticRegistrar sRegisterColumnHeaderParams(&typeid(LLScrollColumnHeader::Params), "scroll_column_header");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterColumnHeaderParams(typeid(LLScrollColumnHeader::Params), "scroll_column_header");
 
 //---------------------------------------------------------------------------
 // LLScrollColumnHeader
diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp
index 2079ff17fc..24ae5c09e9 100644
--- a/indra/llui/lltextbase.cpp
+++ b/indra/llui/lltextbase.cpp
@@ -129,7 +129,7 @@ struct LLTextBase::line_end_compare
 //
 
 // register LLTextBase::Params under name "textbase"
-static LLWidgetNameRegistry::StaticRegistrar sRegisterTextBaseParams(&typeid(LLTextBase::Params), "textbase");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterTextBaseParams(typeid(LLTextBase::Params), "textbase");
 
 LLTextBase::LineSpacingParams::LineSpacingParams()
 :   multiple("multiple", 1.f),
diff --git a/indra/llui/lltooltip.cpp b/indra/llui/lltooltip.cpp
index 74f03618cf..c5b1b5ba1d 100644
--- a/indra/llui/lltooltip.cpp
+++ b/indra/llui/lltooltip.cpp
@@ -129,7 +129,7 @@ void LLToolTipView::drawStickyRect()
 }
 
 // defaults for floater param block pulled from widgets/floater.xml
-static LLWidgetNameRegistry::StaticRegistrar sRegisterInspectorParams(&typeid(LLInspector::Params), "inspector");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterInspectorParams(typeid(LLInspector::Params), "inspector");
 
 //
 // LLToolTip
diff --git a/indra/llui/lluictrlfactory.cpp b/indra/llui/lluictrlfactory.cpp
index 9abccfd9a0..33ffc3dfc6 100644
--- a/indra/llui/lluictrlfactory.cpp
+++ b/indra/llui/lluictrlfactory.cpp
@@ -253,7 +253,7 @@ const LLInitParam::BaseBlock& get_empty_param_block()
 
 // adds a widget and its param block to various registries
 //static
-void LLUICtrlFactory::registerWidget(const std::type_info* widget_type, const std::type_info* param_block_type, const std::string& name)
+void LLUICtrlFactory::registerWidget(std::type_index widget_type, std::type_index param_block_type, const std::string& name)
 {
     // associate parameter block type with template .xml file
     std::string* existing_name = LLWidgetNameRegistry::instance().getValue(param_block_type);
diff --git a/indra/llui/lluictrlfactory.h b/indra/llui/lluictrlfactory.h
index fc069c078f..f44b4ba4dc 100644
--- a/indra/llui/lluictrlfactory.h
+++ b/indra/llui/lluictrlfactory.h
@@ -65,7 +65,7 @@ class LLDefaultChildRegistry : public LLChildRegistry<LLDefaultChildRegistry>
 
 // lookup widget name by type
 class LLWidgetNameRegistry
-:   public LLRegistrySingleton<const std::type_info*, std::string, LLWidgetNameRegistry>
+:   public LLRegistrySingleton<std::type_index, std::string, LLWidgetNameRegistry>
 {
     LLSINGLETON_EMPTY_CTOR(LLWidgetNameRegistry);
 };
@@ -74,7 +74,7 @@ class LLWidgetNameRegistry
 // this is used for schema generation
 //typedef const LLInitParam::BaseBlock& (*empty_param_block_func_t)();
 //class LLDefaultParamBlockRegistry
-//: public LLRegistrySingleton<const std::type_info*, empty_param_block_func_t, LLDefaultParamBlockRegistry>
+//: public LLRegistrySingleton<std::type_index, empty_param_block_func_t, LLDefaultParamBlockRegistry>
 //{
 //  LLSINGLETON(LLDefaultParamBlockRegistry);
 //};
@@ -202,7 +202,7 @@ private:
     static void copyName(LLXMLNodePtr src, LLXMLNodePtr dest);
 
     // helper function for adding widget type info to various registries
-    static void registerWidget(const std::type_info* widget_type, const std::type_info* param_block_type, const std::string& tag);
+    static void registerWidget(std::type_index widget_type, std::type_index param_block_type, const std::string& tag);
 
     static void loadWidgetTemplate(const std::string& widget_tag, LLInitParam::BaseBlock& block);
 
@@ -290,7 +290,7 @@ template <typename PARAM_BLOCK, int DUMMY>
 LLUICtrlFactory::ParamDefaults<PARAM_BLOCK, DUMMY>::ParamDefaults()
 {
     // look up template file for this param block...
-    const std::string* param_block_tag = LLWidgetNameRegistry::instance().getValue(&typeid(PARAM_BLOCK));
+    const std::string* param_block_tag = LLWidgetNameRegistry::instance().getValue(typeid(PARAM_BLOCK));
     if (param_block_tag)
     {   // ...and if it exists, back fill values using the most specific template first
         PARAM_BLOCK params;
@@ -314,12 +314,12 @@ LLChildRegistry<DERIVED>::Register<T>::Register(const char* tag, LLWidgetCreator
 :   LLChildRegistry<DERIVED>::StaticRegistrar(tag, func == nullptr ? (LLWidgetCreatorFunc)&LLUICtrlFactory::defaultBuilder<T> : func)
 {
     // add this widget to various registries
-    LLUICtrlFactory::instance().registerWidget(&typeid(T), &typeid(typename T::Params), tag);
+    LLUICtrlFactory::instance().registerWidget(typeid(T), typeid(typename T::Params), tag);
 
     // since registry_t depends on T, do this in line here
     // TODO: uncomment this for schema generation
     //typedef typename T::child_registry_t registry_t;
-    //LLChildRegistryRegistry::instance().defaultRegistrar().add(&typeid(T), registry_t::instance());
+    //LLChildRegistryRegistry::instance().defaultRegistrar().add(typeid(T), registry_t::instance());
 }
 
 #endif //LLUICTRLFACTORY_H
diff --git a/indra/llui/llxuiparser.cpp b/indra/llui/llxuiparser.cpp
index 8fd85a89a1..560bf0fc27 100644
--- a/indra/llui/llxuiparser.cpp
+++ b/indra/llui/llxuiparser.cpp
@@ -602,7 +602,7 @@ void LLXUIXSDWriter::writeXSD(const std::string& type_name, const std::string& p
     LLXSDWriter::writeXSD(type_name, root_nodep, block, "http://www.lindenlab.com/xui");
 
     // add includes for all possible children
-    const std::type_info* type = *LLWidgetTypeRegistry::instance().getValue(type_name);
+    const std::type_index& type = *LLWidgetTypeRegistry::instance().getValue(type_name);
     const widget_registry_t* widget_registryp = LLChildRegistryRegistry::instance().getValue(type);
 
     // add choices for valid children
diff --git a/indra/llui/llxuiparser.h b/indra/llui/llxuiparser.h
index 2179ae54d3..66d4a37484 100644
--- a/indra/llui/llxuiparser.h
+++ b/indra/llui/llxuiparser.h
@@ -40,7 +40,7 @@ class LLView;
 
 // lookup widget type by name
 class LLWidgetTypeRegistry
-:   public LLRegistrySingleton<std::string, const std::type_info*, LLWidgetTypeRegistry>
+:   public LLRegistrySingleton<std::string, std::type_index, LLWidgetTypeRegistry>
 {
     LLSINGLETON_EMPTY_CTOR(LLWidgetTypeRegistry);
 };
@@ -52,7 +52,7 @@ typedef std::function<LLView* (LLXMLNodePtr node, LLView *parent, LLXMLNodePtr o
 typedef LLRegistry<std::string, LLWidgetCreatorFunc> widget_registry_t;
 
 class LLChildRegistryRegistry
-: public LLRegistrySingleton<const std::type_info*, widget_registry_t, LLChildRegistryRegistry>
+: public LLRegistrySingleton<std::type_index, widget_registry_t, LLChildRegistryRegistry>
 {
     LLSINGLETON_EMPTY_CTOR(LLChildRegistryRegistry);
 };
diff --git a/indra/newview/llavatarlistitem.cpp b/indra/newview/llavatarlistitem.cpp
index 80c7f8beca..de3ce901c1 100644
--- a/indra/newview/llavatarlistitem.cpp
+++ b/indra/newview/llavatarlistitem.cpp
@@ -47,7 +47,7 @@ S32 LLAvatarListItem::sLeftPadding = 0;
 S32 LLAvatarListItem::sNameRightPadding = 0;
 S32 LLAvatarListItem::sChildrenWidths[LLAvatarListItem::ALIC_COUNT];
 
-static LLWidgetNameRegistry::StaticRegistrar sRegisterAvatarListItemParams(&typeid(LLAvatarListItem::Params), "avatar_list_item");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterAvatarListItemParams(typeid(LLAvatarListItem::Params), "avatar_list_item");
 
 LLAvatarListItem::Params::Params()
 :   default_style("default_style"),
diff --git a/indra/newview/llinventorylistitem.cpp b/indra/newview/llinventorylistitem.cpp
index a435a4f7c7..aa6ba6d023 100644
--- a/indra/newview/llinventorylistitem.cpp
+++ b/indra/newview/llinventorylistitem.cpp
@@ -41,7 +41,7 @@
 #include "llinventorymodel.h"
 #include "llviewerinventory.h"
 
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelInventoryListItemBaseParams(&typeid(LLPanelInventoryListItemBase::Params), "inventory_list_item");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelInventoryListItemBaseParams(typeid(LLPanelInventoryListItemBase::Params), "inventory_list_item");
 
 constexpr S32 WIDGET_SPACING = 3;
 constexpr S32 FAVORITE_IMAGE_SIZE = 14;
diff --git a/indra/newview/llwearableitemslist.cpp b/indra/newview/llwearableitemslist.cpp
index cc593fe7b4..f639024228 100644
--- a/indra/newview/llwearableitemslist.cpp
+++ b/indra/newview/llwearableitemslist.cpp
@@ -82,7 +82,7 @@ LLPanelWearableListItem::LLPanelWearableListItem(LLViewerInventoryItem* item, co
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelWearableOutfitItem(&typeid(LLPanelWearableOutfitItem::Params), "wearable_outfit_list_item");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelWearableOutfitItem(typeid(LLPanelWearableOutfitItem::Params), "wearable_outfit_list_item");
 
 LLPanelWearableOutfitItem::Params::Params()
 :   add_btn("add_btn"),
@@ -222,7 +222,7 @@ void LLPanelWearableOutfitItem::updateItem(const std::string& name,
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelClothingListItem(&typeid(LLPanelClothingListItem::Params), "clothing_list_item");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelClothingListItem(typeid(LLPanelClothingListItem::Params), "clothing_list_item");
 
 
 LLPanelClothingListItem::Params::Params()
@@ -309,7 +309,7 @@ bool LLPanelClothingListItem::postBuild()
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelBodyPartsListItem(&typeid(LLPanelBodyPartsListItem::Params), "bodyparts_list_item");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelBodyPartsListItem(typeid(LLPanelBodyPartsListItem::Params), "bodyparts_list_item");
 
 
 LLPanelBodyPartsListItem::Params::Params()
@@ -380,7 +380,7 @@ bool LLPanelBodyPartsListItem::postBuild()
     return true;
 }
 
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelDeletableWearableListItem(&typeid(LLPanelDeletableWearableListItem::Params), "deletable_wearable_list_item");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelDeletableWearableListItem(typeid(LLPanelDeletableWearableListItem::Params), "deletable_wearable_list_item");
 
 LLPanelDeletableWearableListItem::Params::Params()
 :   delete_btn("delete_btn")
@@ -467,7 +467,7 @@ void LLPanelAttachmentListItem::updateItem(const std::string& name,
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelDummyClothingListItem(&typeid(LLPanelDummyClothingListItem::Params), "dummy_clothing_list_item");
+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelDummyClothingListItem(typeid(LLPanelDummyClothingListItem::Params), "dummy_clothing_list_item");
 
 LLPanelDummyClothingListItem::Params::Params()
 :   add_panel("add_panel"),