Add DemangleSymbol function

Author: Vipul-Cariappa

include/clang/Interpreter/CppInterOp.h

@@ -185,6 +185,9 @@ namespace Cpp {
   ///\returns the version string information of the library.
   CPPINTEROP_API std::string GetVersion();
 
+  ///\returns the demangled representation of the given mangled_name
+  CPPINTEROP_API std::string DemangleSymbol(const std::string& mangled_name);
+
   /// Enables or disables the debugging printouts on stderr.
   /// Debugging output can be enabled also by the environment variable
   /// CPPINTEROP_EXTRA_INTERPRETER_ARGS. For example,

lib/Interpreter/CppInterOp.cpp

@@ -31,6 +31,7 @@
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_os_ostream.h"
@@ -155,6 +156,13 @@ namespace Cpp {
     return fullVersion + "[" + clang::getClangFullVersion() + "])\n";
   }
 
+  std::string DemangleSymbol(const std::string& mangled_name) {
+    char* demangle = itaniumDemangle(mangled_name);
+    std::string res(demangle);
+    std::free(demangle);
+    return res;
+  }
+
   void EnableDebugOutput(bool value/* =true*/) {
     llvm::DebugFlag = value;
   }

unittests/CppInterOp/ScopeReflectionTest.cpp

@@ -17,6 +17,48 @@ using namespace TestUtils;
 using namespace llvm;
 using namespace clang;
 
+TEST(ScopeReflectionTest, DemangleSymbol) {
+  std::string code = R"(
+    class C { public: virtual ~C() {} };
+    namespace scope {
+        class C { public: virtual ~C() {} };
+    }
+    void *get_c() { return new C; }
+    void *get_scope_c() { return new scope::C; }
+  )";
+
+  EXPECT_EQ(Cpp::Declare(code.c_str()), 0);
+
+  Cpp::TCppScope_t get_c = Cpp::GetNamed("get_c");
+  Cpp::TCppScope_t get_scope_c = Cpp::GetNamed("get_scope_c");
+  Cpp::TCppScope_t C = Cpp::GetNamed("C");
+  Cpp::TCppScope_t scope_C = Cpp::GetNamed("C", Cpp::GetNamed("scope"));
+
+  auto get_c_callable = Cpp::MakeFunctionCallable(get_c);
+  EXPECT_TRUE(get_c_callable.getKind() == Cpp::JitCall::kGenericCall);
+  void* c = nullptr;
+  get_c_callable.Invoke(&c);
+  EXPECT_TRUE(c);
+
+  auto get_scope_c_callable = Cpp::MakeFunctionCallable(get_scope_c);
+  EXPECT_TRUE(get_scope_c_callable.getKind() == Cpp::JitCall::kGenericCall);
+  void* scope_c = nullptr;
+  get_scope_c_callable.Invoke(&scope_c);
+  EXPECT_TRUE(scope_c);
+
+  struct DynamicType {
+    // Helper class to enable typeid on any address
+    // Used in code similar to:
+    //    typeid(*(DynamicType*)void_ptr);
+    virtual ~DynamicType() {}
+  };
+
+  EXPECT_EQ(Cpp::DemangleSymbol(typeid(*(DynamicType*)c).name()),
+            Cpp::GetQualifiedCompleteName(C));
+  EXPECT_EQ(Cpp::DemangleSymbol(typeid(*(DynamicType*)scope_c).name()),
+            Cpp::GetQualifiedCompleteName(scope_C));
+}
+
 TEST(ScopeReflectionTest, IsAggregate) {
   std::vector<Decl *> Decls;
   std::string code = R"(