Introduce TypeNameTraits for llvm::getTypeName()

[logan]

Summary

This commit introduces TypeNameTraits as a customization point for
llvm::getTypeName<T>().

Before this commit, developers can specialize llvm::getTypeName<T>()
function template to customize the behavior. However, C++ programming
language doesn't allow function template partial specialization.

After this commit, if someone wants to partial specialize
getTypeName() for a class template, they can define:

namespace llvm {

template <typename T>
class TypeNameTraits<SomeContainer<T>> {
public:
  static llvm::StringRef getTypeName() {
    // ... a different implementation ...
  }
};

}  // namespace llvm

And then, calling llvm::getTypeName<SomeContainer<int>>() will be
dispatched to the partial specialized version.

llvm/include/llvm/Support/TypeName.h

 //===- TypeName.h -----------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_TYPENAME_H
 #define LLVM_SUPPORT_TYPENAME_H
 
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 
-/// We provide a function which tries to compute the (demangled) name of a type
-/// statically.
+/// TypeNameTraits computes the (demangled) name of a type statically.
 ///
-/// This routine may fail on some platforms or for particularly unusual types.
-/// Do not use it for anything other than logging and debugging aids. It isn't
-/// portable or dependendable in any real sense.
+/// This type trait may fail on some platforms or for particularly unusual
+/// types. Do not use it for anything other than logging and debugging aids.
+/// It isn't portable or dependable in any real sense.
 ///
 /// The returned StringRef will point into a static storage duration string.
 /// However, it may not be null terminated and may be some strangely aligned
 /// inner substring of a larger string.
+///
+/// This type trait serves as a customization point for the
+/// llvm::getTypeName<T>() function defined below.
 template <typename DesiredTypeName>
-inline StringRef getTypeName() {
+class TypeNameTraits {
+public:
+  static inline StringRef getTypeName() {
 #if defined(__clang__) || defined(__GNUC__)
     StringRef Name = __PRETTY_FUNCTION__;
 
     StringRef Key = "DesiredTypeName = ";
     Name = Name.substr(Name.find(Key));
     assert(!Name.empty() && "Unable to find the template parameter!");
     Name = Name.drop_front(Key.size());
 
     assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
     return Name.drop_back(1);
 #elif defined(_MSC_VER)
     StringRef Name = __FUNCSIG__;
 
     StringRef Key = "getTypeName<";
     Name = Name.substr(Name.find(Key));
     assert(!Name.empty() && "Unable to find the function name!");
     Name = Name.drop_front(Key.size());
 
     for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
       if (Name.startswith(Prefix)) {
         Name = Name.drop_front(Prefix.size());
         break;
       }
 
     auto AnglePos = Name.rfind('>');
     assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
     return Name.substr(0, AnglePos);
 #else
-  // No known technique for statically extracting a type name on this compiler.
-  // We return a string that is unlikely to look like any type in LLVM.
+    // No known technique for statically extracting a type name on this
+    // compiler. We return a string that is unlikely to look like any type in
+    // LLVM.
     return "UNKNOWN_TYPE";
 #endif
   }
+};
+
+/// getTypeName computes the (demangled) name of a type statically.
+template <typename DesiredTypeName>
+inline StringRef getTypeName() {
+  return TypeNameTraits<DesiredTypeName>::getTypeName();
+}
 
 }
 
 #endif

llvm/unittests/Support/TypeNameTest.cpp

 
 using namespace llvm;
 
 namespace {
 namespace N1 {
 struct S1 {};
 class C1 {};
 union U1 {};
+}  // namespace N1
+
+template <typename T> class A {};
+}  // anonymous namespace
+
+namespace llvm {
+
+template <typename T>
+class TypeNameTraits<A<T>> {
+public:
+  static inline StringRef getTypeName() {
+    return "customized_type_name";
   }
+};
+
+}  // namespace llvm
+
+namespace {
 
 TEST(TypeNameTest, Names) {
   struct S2 {};
 
   StringRef S1Name = getTypeName<N1::S1>();
   StringRef C1Name = getTypeName<N1::C1>();
   StringRef U1Name = getTypeName<N1::U1>();
   StringRef S2Name = getTypeName<S2>();

 #else
   EXPECT_EQ("UNKNOWN_TYPE", S1Name);
   EXPECT_EQ("UNKNOWN_TYPE", C1Name);
   EXPECT_EQ("UNKNOWN_TYPE", U1Name);
   EXPECT_EQ("UNKNOWN_TYPE", S2Name);
 #endif
 }
 
-} // end anonymous namespace
+TEST(TestNameTest, TypeNameTraitsPartialSpecialization) {
+  StringRef AIntName = getTypeName<A<int>>();
+  EXPECT_EQ("customized_type_name", AIntName);
+}
+
+}  // anonymous namespace