Make all maybeMangleDeclName overrides return a std::string.

Author: marsupial

include/cling/Utils/AST.h

@@ -64,20 +64,23 @@ namespace utils {
 
     ///\brief Get the mangled name of a GlobalDecl.
     ///
-    ///\param [in]  GD - try to mangle this decl's name.
-    ///\param [out] mangledName - put the mangled name in here.
+    ///\param [in]  GD - Try to mangle this decl's name.
     ///
-    void maybeMangleDeclName(const clang::GlobalDecl& GD,
-                             std::string& mangledName);
+    ///\returns The mangled or pure name (when ND should not be mangled) on
+    /// success or an empty string on failure.
+    ///
+    std::string maybeMangleDeclName(const clang::GlobalDecl& GD);
 
-    ///\brief Get the mangled name of a clang::Decl subclass. FunctionDecls and
-    /// VarDecls are currently supported.
+    ///\brief Get the mangled name of a clang::Decl subclass. FunctionDecl,
+    /// VarDecl, ValueDecl, and NamedDecl are currently supported.
     ///
-    ///\param [in]  Decl - try to mangle this decl's name.
-    ///\param [out] mangledName - put the mangled name in here.
+    ///\param [in]  Decl - Try to mangle this decl's name.
+    ///
+    ///\returns The mangled or pure name (when ND should not be mangled) on
+    /// success or an empty string on failure.
     ///
     template <typename T>
-    void maybeMangleDeclName(const T* Decl, std::string& mangledName);
+    std::string maybeMangleDeclName(const T* Decl);
 
     ///\brief Retrieves the last expression of a function body. If it was a
     /// DeclStmt with a variable declaration, creates DeclRefExpr and adds it to

lib/Interpreter/DeclUnloader.cpp

@@ -853,17 +853,16 @@ bool DeclUnloader::VisitRedeclarable(clang::Redeclarable<T>* R, DeclContext* DC)
         utils::DiagnosticsOverride IgnoreMangleErrors(m_Sema->getDiagnostics());
 #endif
 #endif
-        utils::Analyze::maybeMangleDeclName(GD, mangledName);
+        utils::Analyze::maybeMangleDeclName(GD).swap(mangledName);
       }
 
       // Handle static locals. void func() { static int var; } is represented
       // in the llvm::Module is a global named @func.var
       if (const VarDecl* VD = dyn_cast<VarDecl>(GD.getDecl())) {
         if (VD->isStaticLocal()) {
-          std::string functionMangledName;
-          GlobalDecl FDGD(cast<FunctionDecl>(VD->getDeclContext()));
-          utils::Analyze::maybeMangleDeclName(FDGD, functionMangledName);
-          mangledName = functionMangledName + "." + mangledName;
+          mangledName = utils::Analyze::maybeMangleDeclName(GlobalDecl(
+                            cast<FunctionDecl>(VD->getDeclContext()))) +
+                        "." + mangledName;
         }
       }
 

lib/Interpreter/Interpreter.cpp

@@ -983,10 +983,8 @@ namespace cling {
     if (!FD)
       return kExeUnkownFunction;
 
-    std::string mangledNameIfNeeded;
-    utils::Analyze::maybeMangleDeclName(FD, mangledNameIfNeeded);
     IncrementalExecutor::ExecutionResult ExeRes =
-       m_Executor->executeWrapper(mangledNameIfNeeded, res);
+       m_Executor->executeWrapper(utils::Analyze::maybeMangleDeclName(FD), res);
     return ConvertExecutionResult(ExeRes);
   }
 
@@ -1550,9 +1548,7 @@ namespace cling {
   void* Interpreter::getAddressOfGlobal(const GlobalDecl& GD,
                                         bool* fromJIT /*=0*/) const {
     // Return a symbol's address, and whether it was jitted.
-    std::string mangledName;
-    utils::Analyze::maybeMangleDeclName(GD, mangledName);
-    return getAddressOfGlobal(mangledName, fromJIT);
+    return getAddressOfGlobal(utils::Analyze::maybeMangleDeclName(GD), fromJIT);
   }
 
   void* Interpreter::getAddressOfGlobal(llvm::StringRef SymName,

lib/Utils/AST.cpp

@@ -107,21 +107,29 @@ namespace utils {
       }
       return RawStr.str();
     }
-    
-    void maybeMangleDeclName(const GlobalDecl& GD, std::string& mangledName) {
-      mangledName = maybeMangleDeclName(cast<NamedDecl>(GD.getDecl()), &GD);
+
+    std::string maybeMangleDeclName(const GlobalDecl& GD) {
+      return maybeMangleDeclName(cast<NamedDecl>(GD.getDecl()), &GD);
     }
 
     template <>
-    void maybeMangleDeclName<FunctionDecl>(const FunctionDecl* FD,
-                                           std::string& mangledName) {
-      return maybeMangleDeclName(GlobalDecl(FD), mangledName);
+    std::string maybeMangleDeclName<FunctionDecl>(const FunctionDecl* FD) {
+      return maybeMangleDeclName(GlobalDecl(FD));
+    }
+
+    template <>
+    std::string maybeMangleDeclName<VarDecl>(const VarDecl* VD) {
+      return maybeMangleDeclName(GlobalDecl(VD));
+    }
+
+    template <>
+    std::string maybeMangleDeclName<ValueDecl>(const ValueDecl* VD) {
+      return maybeMangleDeclName(cast<NamedDecl>(VD), nullptr);
     }
 
     template <>
-    void maybeMangleDeclName<VarDecl>(const VarDecl* VD,
-                                      std::string& mangledName) {
-      return maybeMangleDeclName(GlobalDecl(VD), mangledName);
+    std::string maybeMangleDeclName<NamedDecl>(const NamedDecl* ND) {
+      return maybeMangleDeclName(ND, nullptr);
     }
   }