diff --git a/plugins/cpp/model/include/model/cppastnode.h b/plugins/cpp/model/include/model/cppastnode.h
index 8b7e4cec8..ab6a8bc48 100644
--- a/plugins/cpp/model/include/model/cppastnode.h
+++ b/plugins/cpp/model/include/model/cppastnode.h
@@ -70,7 +70,7 @@ struct CppAstNode
   #pragma db null
   FileLoc location;
 
-  std::uint64_t mangledNameHash;
+  std::uint64_t entityHash;
 
   SymbolType symbolType = SymbolType::Other;
 
@@ -84,7 +84,7 @@ struct CppAstNode
   bool operator==(const CppAstNode& other) const { return id == other.id; }
 
 #pragma db index("location_file_idx") member(location.file)
-#pragma db index("mangledNameHash_astType_idx") members(mangledNameHash, astType)
+#pragma db index("entityHash_astType_idx") members(entityHash, astType)
 #pragma db index("astType_symbolType_idx") members(astType, symbolType)
 };
 
@@ -183,7 +183,7 @@ inline std::uint64_t createIdentifier(const CppAstNode& astNode_)
 
   res
     .append(astNode_.astValue).append(":")
-    .append(std::to_string(astNode_.mangledNameHash)).append(":")
+    .append(std::to_string(astNode_.entityHash)).append(":")
     .append(std::to_string(
       static_cast<SymbolTypeInt>(astNode_.symbolType))).append(":")
     .append(std::to_string(
diff --git a/plugins/cpp/model/include/model/cppdoccomment.h b/plugins/cpp/model/include/model/cppdoccomment.h
index 6fc8635ab..1415bc5b0 100644
--- a/plugins/cpp/model/include/model/cppdoccomment.h
+++ b/plugins/cpp/model/include/model/cppdoccomment.h
@@ -29,7 +29,7 @@ struct CppDocComment
   std::string content;
 
   #pragma db not_null index
-  unsigned long long mangledNameHash;
+  unsigned long long entityHash;
 };
 
 } //model
diff --git a/plugins/cpp/model/include/model/cppentity.h b/plugins/cpp/model/include/model/cppentity.h
index b18b60798..68953498d 100644
--- a/plugins/cpp/model/include/model/cppentity.h
+++ b/plugins/cpp/model/include/model/cppentity.h
@@ -27,14 +27,14 @@ struct CppEntity
   #pragma db unique
   CppAstNodeId astNodeId;
 
-  std::uint64_t mangledNameHash = 0;
+  std::uint64_t entityHash = 0;
 
   std::string name;
   std::string qualifiedName;
 
   std::set<Tag> tags;
 
-#pragma db index member(mangledNameHash)
+#pragma db index member(entityHash)
 };
 
 typedef std::shared_ptr<CppEntity> CppEntityPtr;
diff --git a/plugins/cpp/model/include/model/cppenum.h b/plugins/cpp/model/include/model/cppenum.h
index d4d49b044..30ce3f025 100644
--- a/plugins/cpp/model/include/model/cppenum.h
+++ b/plugins/cpp/model/include/model/cppenum.h
@@ -19,7 +19,7 @@ struct CppEnumConstant : CppEntity
 
     ret
       .append("\nid = ").append(std::to_string(id))
-      .append("\nmangledNameHash = ").append(std::to_string(mangledNameHash))
+      .append("\nentityHash = ").append(std::to_string(entityHash))
       .append("\nqualifiedName = ").append(qualifiedName)
       .append("\nvalue = ").append(std::to_string(value));
 
@@ -47,7 +47,7 @@ struct CppEnum : CppEntity
 
     ret
       .append("\nid = ").append(std::to_string(id))
-      .append("\nmangledNameHash = ").append(std::to_string(mangledNameHash))
+      .append("\nentityHash = ").append(std::to_string(entityHash))
       .append("\nqualifiedName = ").append(qualifiedName);
 
     if (!tags.empty())
diff --git a/plugins/cpp/model/include/model/cppfunction.h b/plugins/cpp/model/include/model/cppfunction.h
index e3c662bc9..f75e52e7f 100644
--- a/plugins/cpp/model/include/model/cppfunction.h
+++ b/plugins/cpp/model/include/model/cppfunction.h
@@ -23,7 +23,7 @@ struct CppFunction : CppTypedEntity
   {
     return std::string("CppFunction")
       .append("\nid = ").append(std::to_string(id))
-      .append("\nmangledNameHash = ").append(std::to_string(mangledNameHash))
+      .append("\nentityHash = ").append(std::to_string(entityHash))
       .append("\nqualifiedName = ").append(qualifiedName)
       .append("\nqualifiedType = ").append(qualifiedType);
   }
diff --git a/plugins/cpp/model/include/model/cppmacro.h b/plugins/cpp/model/include/model/cppmacro.h
index beb84bf5f..8919adaa6 100644
--- a/plugins/cpp/model/include/model/cppmacro.h
+++ b/plugins/cpp/model/include/model/cppmacro.h
@@ -18,7 +18,7 @@ struct CppMacro : CppEntity
 
     ret
       .append("\nid = ").append(std::to_string(id))
-      .append("\nmangledNameHash = ").append(std::to_string(mangledNameHash))
+      .append("\nentityHash = ").append(std::to_string(entityHash))
       .append("\nqualifiedName = ").append(qualifiedName);
 
     if (!tags.empty())
diff --git a/plugins/cpp/model/include/model/cppnamespace.h b/plugins/cpp/model/include/model/cppnamespace.h
index 0f50e6e22..d530ff7d2 100644
--- a/plugins/cpp/model/include/model/cppnamespace.h
+++ b/plugins/cpp/model/include/model/cppnamespace.h
@@ -17,7 +17,7 @@ struct CppNamespace : CppEntity
 
     ret
       .append("\nid = ").append(std::to_string(id))
-      .append("\nmangledNameHash = ").append(std::to_string(mangledNameHash))
+      .append("\nentityHash = ").append(std::to_string(entityHash))
       .append("\nqualifiedName = ").append(qualifiedName);
 
     if (!tags.empty())
diff --git a/plugins/cpp/model/include/model/cpprecord.h b/plugins/cpp/model/include/model/cpprecord.h
index efdbc6804..ae9f15834 100644
--- a/plugins/cpp/model/include/model/cpprecord.h
+++ b/plugins/cpp/model/include/model/cpprecord.h
@@ -58,7 +58,7 @@ struct CppRecord : CppEntity
 
     ret
       .append("\nid = ").append(std::to_string(id))
-      .append("\nmangledNameHash = ").append(std::to_string(mangledNameHash))
+      .append("\nentityHash = ").append(std::to_string(entityHash))
       .append("\nqualifiedName = ").append(qualifiedName)
       .append("\nisAbstract = ").append(std::to_string(isAbstract))
       .append("\nisPOD = ").append(std::to_string(isPOD));
diff --git a/plugins/cpp/model/include/model/cpptypedef.h b/plugins/cpp/model/include/model/cpptypedef.h
index d631f02bf..334c56120 100644
--- a/plugins/cpp/model/include/model/cpptypedef.h
+++ b/plugins/cpp/model/include/model/cpptypedef.h
@@ -15,7 +15,7 @@ struct CppTypedef : CppTypedEntity
   {
     return std::string("CppTypedef")
       .append("\nid = ").append(std::to_string(id))
-      .append("\nmangledNameHash = ").append(std::to_string(mangledNameHash))
+      .append("\nentityHash = ").append(std::to_string(entityHash))
       .append("\nqualifiedName = ").append(qualifiedName)
       .append("\nqualifiedType = ").append(qualifiedType);
   }
diff --git a/plugins/cpp/model/include/model/cppvariable.h b/plugins/cpp/model/include/model/cppvariable.h
index f10264dfe..886b97ac4 100644
--- a/plugins/cpp/model/include/model/cppvariable.h
+++ b/plugins/cpp/model/include/model/cppvariable.h
@@ -15,7 +15,7 @@ struct CppVariable : CppTypedEntity
   {
     return std::string("CppVariable")
       .append("\nid = ").append(std::to_string(id))
-      .append("\nmangledNameHash = ").append(std::to_string(mangledNameHash))
+      .append("\nentityHash = ").append(std::to_string(entityHash))
       .append("\nqualifiedName = ").append(qualifiedName)
       .append("\nqualifiedType = ").append(qualifiedType);
   }
diff --git a/plugins/cpp/parser/CMakeLists.txt b/plugins/cpp/parser/CMakeLists.txt
index d889a5ba5..136d25f02 100644
--- a/plugins/cpp/parser/CMakeLists.txt
+++ b/plugins/cpp/parser/CMakeLists.txt
@@ -39,7 +39,7 @@ add_definitions(${LLVM_DEFINITIONS})
 add_library(cppparser SHARED
   src/cppparser.cpp
   src/symbolhelper.cpp
-  src/manglednamecache.cpp
+  src/entitycache.cpp
   src/ppincludecallback.cpp
   src/ppmacrocallback.cpp
   src/relationcollector.cpp
@@ -60,6 +60,7 @@ target_link_libraries(cppparser
   clangAST
   clangLex
   clangBasic
+  clangIndex
   clang)
 
 target_compile_options(cppparser PUBLIC -Wno-unknown-pragmas)
diff --git a/plugins/cpp/parser/src/clangastvisitor.h b/plugins/cpp/parser/src/clangastvisitor.h
index 0a1b3aa3d..23039929a 100644
--- a/plugins/cpp/parser/src/clangastvisitor.h
+++ b/plugins/cpp/parser/src/clangastvisitor.h
@@ -39,7 +39,7 @@
 
 #include <cppparser/filelocutil.h>
 
-#include "manglednamecache.h"
+#include "entitycache.h"
 #include "symbolhelper.h"
 
 namespace cc
@@ -70,7 +70,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
   ClangASTVisitor(
     ParserContext& ctx_,
     clang::ASTContext& astContext_,
-    MangledNameCache& mangledNameCache_,
+    EntityCache& entityCache_,
     std::unordered_map<const void*, model::CppAstNodeId>& clangToAstNodeId_)
     : _isImplicit(false),
       _ctx(ctx_),
@@ -79,7 +79,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       _astContext(astContext_),
       _mngCtx(astContext_.createMangleContext()),
       _cppSourceType("CPP"),
-      _mangledNameCache(mangledNameCache_),
+      _entityCache(entityCache_),
       _clangToAstNodeId(clangToAstNodeId_)
   {
   }
@@ -334,7 +334,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     astNode->astType = model::CppAstNode::AstType::TypeLocation;
     astNode->astValue = td->getNameAsString();
     astNode->symbolType = model::CppAstNode::SymbolType::Typedef;
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, td));
+    astNode->entityHash = util::fnvHash(getUSR(td));
 
     _locToTypeLoc[tl_.getBeginLoc().getRawEncoding()] = astNode;
 
@@ -354,7 +354,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     astNode->astType = model::CppAstNode::AstType::TypeLocation;
     astNode->astValue = ed->getNameAsString();
     astNode->symbolType = model::CppAstNode::SymbolType::Enum;
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, ed));
+    astNode->entityHash = util::fnvHash(getUSR(ed));
 
     _locToTypeLoc[tl_.getBeginLoc().getRawEncoding()] = astNode;
 
@@ -374,7 +374,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     astNode->astType = model::CppAstNode::AstType::TypeLocation;
     astNode->astValue = rd->getNameAsString();
     astNode->symbolType = model::CppAstNode::SymbolType::Type;
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, rd));
+    astNode->entityHash = util::fnvHash(getUSR(rd));
 
     _locToTypeLoc[tl_.getBeginLoc().getRawEncoding()] = astNode;
 
@@ -396,8 +396,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     astNode->astValue = getDeclPartAsString(_clangSrcMgr, rd_);
     astNode->location = getFileLoc(rd_->getBeginLoc(), rd_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(
-      getMangledName(_mngCtx, rd_, astNode->location));
+    astNode->entityHash = util::fnvHash(getUSR(rd_));
     astNode->symbolType = model::CppAstNode::SymbolType::Type;
     astNode->astType
       = rd_->isThisDeclarationADefinition()
@@ -419,7 +418,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     model::CppRecordPtr cppRecord = _typeStack.top();
 
     cppRecord->astNodeId = astNode->id;
-    cppRecord->mangledNameHash = astNode->mangledNameHash;
+    cppRecord->entityHash = astNode->entityHash;
     cppRecord->name = rd_->getNameAsString();
     cppRecord->qualifiedName = rd_->getQualifiedNameAsString();
     if (const clang::CXXRecordDecl* crd
@@ -447,9 +446,8 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
             = std::make_shared<model::CppInheritance>();
           _inheritances.push_back(inheritance);
 
-          inheritance->derived = cppRecord->mangledNameHash;
-          inheritance->base
-            = util::fnvHash(getMangledName(_mngCtx, baseDecl));
+          inheritance->derived = cppRecord->entityHash;
+          inheritance->base = util::fnvHash(getUSR(baseDecl));
           inheritance->isVirtual = it->isVirtual();
           inheritance->visibility = getVisibility(it->getAccessSpecifier());
 
@@ -482,9 +480,8 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
             = std::make_shared<model::CppFriendship>();
           _friends.push_back(friendship);
 
-          friendship->target = cppRecord->mangledNameHash;
-          friendship->theFriend
-            = util::fnvHash(getMangledName(_mngCtx, cxxRecordDecl));
+          friendship->target = cppRecord->entityHash;
+          friendship->theFriend = util::fnvHash(getUSR(cxxRecordDecl));
 
           clang::SourceRange range = (*it)->getSourceRange();
           _locToAstValue[tsi->getTypeLoc().getBeginLoc().getRawEncoding()]
@@ -499,9 +496,8 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
             = std::make_shared<model::CppFriendship>();
           _friends.push_back(friendship);
 
-          friendship->target = cppRecord->mangledNameHash;
-          friendship->theFriend
-            = util::fnvHash(getMangledName(_mngCtx, friendDecl));
+          friendship->target = cppRecord->entityHash;
+          friendship->theFriend = util::fnvHash(getUSR(friendDecl));
         }
       }
     }
@@ -517,7 +513,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     astNode->astValue = getDeclPartAsString(_clangSrcMgr, ed_);
     astNode->location = getFileLoc(ed_->getBeginLoc(), ed_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, ed_));
+    astNode->entityHash = util::fnvHash(getUSR(ed_));
     astNode->symbolType = model::CppAstNode::SymbolType::Enum;
     astNode->astType
       = ed_->isThisDeclarationADefinition()
@@ -540,7 +536,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       name = "<anonymous>";
 
     cppEnum->astNodeId = astNode->id;
-    cppEnum->mangledNameHash = astNode->mangledNameHash;
+    cppEnum->entityHash = astNode->entityHash;
     cppEnum->name = name;
     cppEnum->qualifiedName = ed_->getQualifiedNameAsString();
 
@@ -555,7 +551,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     astNode->astValue = ec_->getNameAsString();
     astNode->location = getFileLoc(ec_->getBeginLoc(), ec_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, ec_));
+    astNode->entityHash = util::fnvHash(getUSR(ec_));
     astNode->symbolType = model::CppAstNode::SymbolType::EnumConstant;
     astNode->astType = model::CppAstNode::AstType::Definition;
 
@@ -573,7 +569,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     _enumConstants.push_back(enumConstant);
 
     enumConstant->astNodeId = astNode->id;
-    enumConstant->mangledNameHash = astNode->mangledNameHash;
+    enumConstant->entityHash = astNode->entityHash;
     enumConstant->name = ec_->getNameAsString();
     enumConstant->qualifiedName = ec_->getQualifiedNameAsString();
     enumConstant->value = ec_->getInitVal().getLimitedValue();
@@ -587,7 +583,6 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
   {
     //--- CppAstNode ---//
 
-    // TODO: Originally mangled name was appended by some suffix. Why?
     model::CppAstNodePtr astNode = std::make_shared<model::CppAstNode>();
 
     astNode->astValue = getSourceText(
@@ -596,7 +591,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       td_->getSourceRange().getEnd(),
       true);
     astNode->location = getFileLoc(td_->getBeginLoc(), td_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, td_));
+    astNode->entityHash = util::fnvHash(getUSR(td_));
     astNode->symbolType = model::CppAstNode::SymbolType::Typedef;
     astNode->astType = model::CppAstNode::AstType::Definition;
 
@@ -615,10 +610,10 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     clang::QualType qualType = td_->getUnderlyingType();
 
     cppTypedef->astNodeId = astNode->id;
-    cppTypedef->mangledNameHash = astNode->mangledNameHash;
+    cppTypedef->entityHash = astNode->entityHash;
     cppTypedef->name = td_->getNameAsString();
     cppTypedef->qualifiedName = td_->getQualifiedNameAsString();
-    cppTypedef->typeHash = util::fnvHash(getMangledName(_mngCtx, qualType));
+    cppTypedef->typeHash = util::fnvHash(getUSR(qualType, _astContext));
     cppTypedef->qualifiedType = qualType.getAsString();
 
     //--- AST type for aliased type ---//
@@ -644,7 +639,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     astNode->astValue = getSignature(fn_);
     astNode->location = getFileLoc(fn_->getBeginLoc(), fn_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, fn_));
+    astNode->entityHash = util::fnvHash(getUSR(fn_));
     astNode->symbolType = model::CppAstNode::SymbolType::Function;
     astNode->astType
       = fn_->isThisDeclarationADefinition()
@@ -665,10 +660,10 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     clang::QualType qualType = fn_->getReturnType();
 
     cppFunction->astNodeId = astNode->id;
-    cppFunction->mangledNameHash = astNode->mangledNameHash;
+    cppFunction->entityHash = astNode->entityHash;
     cppFunction->name = fn_->getNameAsString();
     cppFunction->qualifiedName = fn_->getQualifiedNameAsString();
-    cppFunction->typeHash = util::fnvHash(getMangledName(_mngCtx, qualType));
+    cppFunction->typeHash = util::fnvHash(getUSR(qualType, _astContext));
     cppFunction->qualifiedType = qualType.getAsString();
 
     clang::CXXMethodDecl* md = llvm::dyn_cast<clang::CXXMethodDecl>(fn_);
@@ -710,7 +705,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       _members.push_back(member);
 
       member->memberAstNode = astNode;
-      member->typeHash = _typeStack.top()->mangledNameHash;
+      member->typeHash = _typeStack.top()->entityHash;
       member->memberTypeHash = cppFunction->typeHash;
       member->kind = model::CppMemberType::Kind::Method;
       member->visibility = getMemberVisibility(md);
@@ -735,8 +730,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       astNode->location = getFileLoc(
         init->getSourceRange().getBegin(),
         init->getSourceRange().getEnd());
-      astNode->mangledNameHash = util::fnvHash(
-        getMangledName(_mngCtx, member));
+      astNode->entityHash = util::fnvHash(getUSR(member));
       astNode->symbolType
         = isFunctionPointer(member)
         ? model::CppAstNode::SymbolType::FunctionPtr
@@ -764,7 +758,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       fd_->getSourceRange().getEnd(),
       true);
     astNode->location = getFileLoc(fd_->getBeginLoc(), fd_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, fd_));
+    astNode->entityHash = util::fnvHash(getUSR(fd_));
     astNode->symbolType
       = isFunctionPointer(fd_)
       ? model::CppAstNode::SymbolType::FunctionPtr
@@ -785,9 +779,9 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     clang::QualType qualType = fd_->getType();
 
-    member->typeHash = _typeStack.top()->mangledNameHash;
+    member->typeHash = _typeStack.top()->entityHash;
     member->memberAstNode = astNode;
-    member->memberTypeHash = util::fnvHash(getMangledName(_mngCtx, qualType));
+    member->memberTypeHash = util::fnvHash(getUSR(qualType, _astContext));
     member->kind = model::CppMemberType::Kind::Field;
     member->visibility = getMemberVisibility(fd_);
 
@@ -797,7 +791,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     _variables.push_back(variable);
 
     variable->astNodeId = astNode->id;
-    variable->mangledNameHash = astNode->mangledNameHash;
+    variable->entityHash = astNode->entityHash;
     variable->name = fd_->getNameAsString();
     variable->qualifiedName = fd_->getQualifiedNameAsString();
     variable->typeHash = member->memberTypeHash;
@@ -827,8 +821,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       vd_->getEndLoc(),
       true);
     astNode->location = getFileLoc(vd_->getLocation(), vd_->getLocation());
-    astNode->mangledNameHash = util::fnvHash(
-      getMangledName(_mngCtx, vd_, astNode->location));
+    astNode->entityHash = util::fnvHash(getUSR(vd_));
     astNode->symbolType
       = isFunctionPointer(vd_)
       ? model::CppAstNode::SymbolType::FunctionPtr
@@ -866,10 +859,10 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     clang::QualType qualType = vd_->getType();
 
     variable->astNodeId = astNode->id;
-    variable->mangledNameHash = astNode->mangledNameHash;
+    variable->entityHash = astNode->entityHash;
     variable->name = vd_->getNameAsString();
     variable->qualifiedName = vd_->getQualifiedNameAsString();
-    variable->typeHash = util::fnvHash(getMangledName(_mngCtx, qualType));
+    variable->typeHash = util::fnvHash(getUSR(qualType, _astContext));
     variable->qualifiedType = qualType.getAsString();
 
     if (_functionStack.empty())
@@ -884,7 +877,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
       model::CppMemberTypePtr member = std::make_shared<model::CppMemberType>();
       _members.push_back(member);
 
-      member->typeHash = _typeStack.top()->mangledNameHash;
+      member->typeHash = _typeStack.top()->entityHash;
       member->memberAstNode = astNode;
       member->memberTypeHash = variable->typeHash;
       member->kind = model::CppMemberType::Kind::Field;
@@ -920,14 +913,14 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     model::CppAstNodePtr astNode = std::make_shared<model::CppAstNode>();
 
-    std::string mangledName = getMangledName(_mngCtx, nd_, astNode->location);
     astNode->astValue = getSourceText(
       _clangSrcMgr,
       nd_->getBeginLoc(),
       nd_->getLocation(),
       true);
+    std::string usr = getUSR(nd_);
     astNode->location = getFileLoc(nd_->getBeginLoc(), nd_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(mangledName);
+    astNode->entityHash = util::fnvHash(usr);
     astNode->symbolType = model::CppAstNode::SymbolType::Namespace;
     astNode->astType = model::CppAstNode::AstType::Definition;
 
@@ -944,9 +937,9 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
     _namespaces.push_back(ns);
 
     ns->astNodeId = astNode->id;
-    ns->mangledNameHash = astNode->mangledNameHash;
+    ns->entityHash = astNode->entityHash;
     ns->name = nd_->getNameAsString();
-    ns->qualifiedName = mangledName;
+    ns->qualifiedName = usr;
 
     return true;
   }
@@ -959,7 +952,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     astNode->astValue = getSignature(ctor);
     astNode->location = getFileLoc(ce_->getBeginLoc(), ce_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, ctor));
+    astNode->entityHash = util::fnvHash(getUSR(ctor));
     astNode->symbolType = model::CppAstNode::SymbolType::Function;
     astNode->astType = model::CppAstNode::AstType::Usage;
     astNode->visibleInSourceCode = false;
@@ -987,8 +980,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     astNode->astValue = getSignature(functionDecl);
     astNode->location = getFileLoc(ne_->getBeginLoc(), ne_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(
-      getMangledName(_mngCtx, functionDecl));
+    astNode->entityHash = util::fnvHash(getUSR(functionDecl));
     astNode->symbolType = model::CppAstNode::SymbolType::Function;
     astNode->astType = model::CppAstNode::AstType::Usage;
 
@@ -1022,8 +1014,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     astNode->astValue = getSignature(functionDecl);
     astNode->location = getFileLoc(de_->getBeginLoc(), de_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(
-      getMangledName(_mngCtx, functionDecl));
+    astNode->entityHash = util::fnvHash(getUSR(functionDecl));
     astNode->symbolType = model::CppAstNode::SymbolType::Function;
     astNode->astType = model::CppAstNode::AstType::Usage;
     astNode->id = model::createIdentifier(*astNode);
@@ -1049,17 +1040,14 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     model::CppAstNodePtr astNode = std::make_shared<model::CppAstNode>();
 
-    std::string mangledName = getMangledName(
-      _mngCtx,
-      namedCallee,
-      getFileLoc(namedCallee->getBeginLoc(), namedCallee->getEndLoc()));
+    std::string usr = getUSR(namedCallee);
 
     astNode->astValue
       = funcCallee
       ? getSignature(funcCallee)
       : namedCallee->getNameAsString();
     astNode->location = getFileLoc(ce_->getBeginLoc(), ce_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(mangledName);
+    astNode->entityHash = util::fnvHash(usr);
     astNode->symbolType = model::CppAstNode::SymbolType::Function;
     astNode->astType
       = isVirtualCall(ce_)
@@ -1100,8 +1088,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
         astNode->astValue = vd->getNameAsString();
 
       astNode->location = getFileLoc(dr_->getBeginLoc(), dr_->getEndLoc());
-      astNode->mangledNameHash = util::fnvHash(
-        getMangledName(_mngCtx, vd, location));
+      astNode->entityHash = util::fnvHash(getUSR(vd));
       astNode->symbolType
         = isFunctionPointer(vd)
         ? model::CppAstNode::SymbolType::FunctionPtr
@@ -1131,7 +1118,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
         astNode->astValue = ec->getNameAsString();
 
       astNode->location = getFileLoc(dr_->getBeginLoc(), dr_->getEndLoc());
-      astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, ec));
+      astNode->entityHash = util::fnvHash(getUSR(ec));
       astNode->symbolType = model::CppAstNode::SymbolType::EnumConstant;
       astNode->astType = model::CppAstNode::AstType::Usage;
 
@@ -1156,7 +1143,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
     astNode->astValue = method ? getSignature(method) : vd->getNameAsString();
     astNode->location = getFileLoc(me_->getBeginLoc(), me_->getEndLoc());
-    astNode->mangledNameHash = util::fnvHash(getMangledName(_mngCtx, vd));
+    astNode->entityHash = util::fnvHash(getUSR(vd));
     astNode->symbolType
       = method
       ? model::CppAstNode::SymbolType::Function
@@ -1190,8 +1177,8 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
 
       model::CppRelationPtr rel = std::make_shared<model::CppRelation>();
       rel->kind = model::CppRelation::Kind::Override;
-      rel->lhs = _mangledNameCache.at(left->second);
-      rel->rhs = _mangledNameCache.at(right->second);
+      rel->lhs = _entityCache.at(left->second);
+      rel->rhs = _entityCache.at(right->second);
       _relations.push_back(rel);
     }
 
@@ -1213,7 +1200,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
   bool insertToCache(const void* clangPtr_, model::CppAstNodePtr node_)
   {
     _clangToAstNodeId[clangPtr_] = node_->id;
-    return _mangledNameCache.insert(*node_);
+    return _entityCache.insert(*node_);
   }
 
   /**
@@ -1489,7 +1476,7 @@ class ClangASTVisitor : public clang::RecursiveASTVisitor<ClangASTVisitor>
   const std::string _cppSourceType;
   std::unordered_map<std::string, model::FilePtr> _files;
 
-  MangledNameCache& _mangledNameCache;
+  EntityCache& _entityCache;
   std::unordered_map<const void*, model::CppAstNodeId>& _clangToAstNodeId;
 
   // clang::TypeLoc for type names is like clang::DeclRefExpr for objects: it
diff --git a/plugins/cpp/parser/src/cppparser.cpp b/plugins/cpp/parser/src/cppparser.cpp
index 8bce853ac..9e1b99b45 100644
--- a/plugins/cpp/parser/src/cppparser.cpp
+++ b/plugins/cpp/parser/src/cppparser.cpp
@@ -31,7 +31,7 @@
 
 #include "clangastvisitor.h"
 #include "relationcollector.h"
-#include "manglednamecache.h"
+#include "entitycache.h"
 #include "ppincludecallback.h"
 #include "ppmacrocallback.h"
 #include "doccommentcollector.h"
@@ -47,14 +47,14 @@ class VisitorActionFactory : public clang::tooling::FrontendActionFactory
 public:
   static void cleanUp()
   {
-    MyFrontendAction::_mangledNameCache.clear();
+    MyFrontendAction::_entityCache.clear();
   }
 
   static void init(ParserContext& ctx_)
   {
     util::OdbTransaction {ctx_.db} ([&] {
       for (const model::CppAstNode& node : ctx_.db->query<model::CppAstNode>())
-        MyFrontendAction::_mangledNameCache.insert(node);
+        MyFrontendAction::_entityCache.insert(node);
     });
   }
 
@@ -74,8 +74,8 @@ class VisitorActionFactory : public clang::tooling::FrontendActionFactory
     MyConsumer(
       ParserContext& ctx_,
       clang::ASTContext& context_,
-      MangledNameCache& mangledNameCache_)
-        : _mangledNameCache(mangledNameCache_), _ctx(ctx_), _context(context_)
+      EntityCache& entityCache_)
+        : _entityCache(entityCache_), _ctx(ctx_), _context(context_)
     {
     }
 
@@ -83,7 +83,7 @@ class VisitorActionFactory : public clang::tooling::FrontendActionFactory
     {
       {
         ClangASTVisitor clangAstVisitor(
-          _ctx, _context, _mangledNameCache, _clangToAstNodeId);
+          _ctx, _context, _entityCache, _clangToAstNodeId);
         clangAstVisitor.TraverseDecl(context_.getTranslationUnitDecl());
       }
 
@@ -96,7 +96,7 @@ class VisitorActionFactory : public clang::tooling::FrontendActionFactory
       if (!_ctx.options.count("skip-doccomment"))
       {
         DocCommentCollector docCommentCollector(
-          _ctx, _context, _mangledNameCache, _clangToAstNodeId);
+          _ctx, _context, _entityCache, _clangToAstNodeId);
         docCommentCollector.TraverseDecl(context_.getTranslationUnitDecl());
       }
       else
@@ -104,7 +104,7 @@ class VisitorActionFactory : public clang::tooling::FrontendActionFactory
     }
 
   private:
-    MangledNameCache& _mangledNameCache;
+    EntityCache& _entityCache;
     std::unordered_map<const void*, model::CppAstNodeId> _clangToAstNodeId;
 
     ParserContext& _ctx;
@@ -127,9 +127,9 @@ class VisitorActionFactory : public clang::tooling::FrontendActionFactory
       auto& pp = compiler_.getPreprocessor();
 
       pp.addPPCallbacks(std::make_unique<PPIncludeCallback>(
-        _ctx, compiler_.getASTContext(), _mangledNameCache, pp));
+        _ctx, compiler_.getASTContext(), _entityCache, pp));
       pp.addPPCallbacks(std::make_unique<PPMacroCallback>(
-        _ctx, compiler_.getASTContext(), _mangledNameCache, pp));
+        _ctx, compiler_.getASTContext(), _entityCache, pp));
 
       return true;
     }
@@ -138,11 +138,11 @@ class VisitorActionFactory : public clang::tooling::FrontendActionFactory
       clang::CompilerInstance& compiler_, llvm::StringRef) override
     {
       return std::unique_ptr<clang::ASTConsumer>(
-        new MyConsumer(_ctx, compiler_.getASTContext(), _mangledNameCache));
+        new MyConsumer(_ctx, compiler_.getASTContext(), _entityCache));
     }
 
   private:
-    static MangledNameCache _mangledNameCache;
+    static EntityCache _entityCache;
 
     ParserContext& _ctx;
   };
@@ -150,7 +150,7 @@ class VisitorActionFactory : public clang::tooling::FrontendActionFactory
   ParserContext& _ctx;
 };
 
-MangledNameCache VisitorActionFactory::MyFrontendAction::_mangledNameCache;
+EntityCache VisitorActionFactory::MyFrontendAction::_entityCache;
 
 bool CppParser::isSourceFile(const std::string& file_) const
 {
@@ -611,11 +611,11 @@ bool CppParser::cleanupWorker(const std::string& path_)
               {
                 // Delete CppInheritance
                 _ctx.db->erase_query<model::CppInheritance>(
-                  odb::query<model::CppInheritance>::derived == astNode.mangledNameHash);
+                  odb::query<model::CppInheritance>::derived == astNode.entityHash);
 
                 // Delete CppFriendship
                 _ctx.db->erase_query<model::CppFriendship>(
-                  odb::query<model::CppFriendship>::target == astNode.mangledNameHash);
+                  odb::query<model::CppFriendship>::target == astNode.entityHash);
               }
             }
 
diff --git a/plugins/cpp/parser/src/doccommentcollector.h b/plugins/cpp/parser/src/doccommentcollector.h
index 91ea80557..6e98f74aa 100644
--- a/plugins/cpp/parser/src/doccommentcollector.h
+++ b/plugins/cpp/parser/src/doccommentcollector.h
@@ -16,7 +16,7 @@
 #include <model/cppdoccomment-odb.hxx>
 
 #include "doccommentformatter.h"
-#include "manglednamecache.h"
+#include "entitycache.h"
 
 namespace cc
 {
@@ -30,12 +30,12 @@ class DocCommentCollector :
   DocCommentCollector(
     ParserContext& ctx_,
     clang::ASTContext& astContext_,
-    MangledNameCache& mangledNameCache_,
+    EntityCache& entityCache_,
     std::unordered_map<const void*, model::CppAstNodeId>& clangToAstNodeId_)
       : _ctx(ctx_),
         _astContext(astContext_),
         _clangSrcMgr(astContext_.getSourceManager()),
-        _mangledNameCache(mangledNameCache_),
+        _entityCache(entityCache_),
         _clangToAstNodeId(clangToAstNodeId_)
   {
   }
@@ -59,9 +59,9 @@ class DocCommentCollector :
     model::CppDocCommentPtr pc(new model::CppDocComment);
     pc->content = dcFmt.format(fc, _astContext);
     pc->contentHash = util::fnvHash(pc->content);
-    pc->mangledNameHash = _mangledNameCache.at(it->second);
+    pc->entityHash = _entityCache.at(it->second);
     _docComments.insert(std::make_pair(
-      std::make_pair(pc->mangledNameHash, pc->contentHash), pc));
+      std::make_pair(pc->entityHash, pc->contentHash), pc));
 
     return true;
   }
@@ -83,7 +83,7 @@ class DocCommentCollector :
   ParserContext& _ctx;
   const clang::ASTContext& _astContext;
   const clang::SourceManager& _clangSrcMgr;
-  MangledNameCache& _mangledNameCache;
+  EntityCache& _entityCache;
   std::unordered_map<const void*, model::CppAstNodeId>& _clangToAstNodeId;
 };
 
diff --git a/plugins/cpp/parser/src/entitycache.cpp b/plugins/cpp/parser/src/entitycache.cpp
new file mode 100644
index 000000000..63e9ad902
--- /dev/null
+++ b/plugins/cpp/parser/src/entitycache.cpp
@@ -0,0 +1,27 @@
+#include "entitycache.h"
+
+namespace cc
+{
+namespace parser
+{
+
+bool EntityCache::insert(const model::CppAstNode& node_)
+{
+  std::lock_guard<std::mutex> guard(_cacheMutex);
+  return _entityCache.insert(
+    std::make_pair(node_.id, node_.entityHash)).second;
+}
+
+std::uint64_t EntityCache::at(const model::CppAstNodeId& id_) const
+{
+  std::lock_guard<std::mutex> guard(_cacheMutex);
+  return _entityCache.at(id_);
+}
+
+void EntityCache::clear()
+{
+  _entityCache.clear();
+}
+
+}
+}
diff --git a/plugins/cpp/parser/src/manglednamecache.h b/plugins/cpp/parser/src/entitycache.h
similarity index 76%
rename from plugins/cpp/parser/src/manglednamecache.h
rename to plugins/cpp/parser/src/entitycache.h
index 41ff3b9dd..567e57dc1 100644
--- a/plugins/cpp/parser/src/manglednamecache.h
+++ b/plugins/cpp/parser/src/entitycache.h
@@ -1,5 +1,5 @@
-#ifndef CC_PARSER_MANGLEDNAMECACHE_H
-#define CC_PARSER_MANGLEDNAMECACHE_H
+#ifndef CC_PARSER_ENTITYCACHE_H
+#define CC_PARSER_ENTITYCACHE_H
 
 #include <unordered_map>
 #include <mutex>
@@ -12,9 +12,9 @@ namespace parser
 {
 
 /**
- * Thread safe mangled name cache.
+ * Thread safe entity cache.
  */
-class MangledNameCache
+class EntityCache
 {
 public:
   /**
@@ -38,11 +38,11 @@ class MangledNameCache
   void clear();
 
 private:
-  std::unordered_map<model::CppAstNodeId, std::uint64_t> _mangledNameCache;
+  std::unordered_map<model::CppAstNodeId, std::uint64_t> _entityCache;
   mutable std::mutex _cacheMutex;
 };
 
 } // parser
 } // cc
 
-#endif // CC_PARSER_MANGLEDNAMECACHE_H
+#endif // CC_PARSER_ENTITYCACHE_H
diff --git a/plugins/cpp/parser/src/manglednamecache.cpp b/plugins/cpp/parser/src/manglednamecache.cpp
deleted file mode 100644
index a841752db..000000000
--- a/plugins/cpp/parser/src/manglednamecache.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "manglednamecache.h"
-
-namespace cc
-{
-namespace parser
-{
-
-bool MangledNameCache::insert(const model::CppAstNode& node_)
-{
-  std::lock_guard<std::mutex> guard(_cacheMutex);
-  return _mangledNameCache.insert(
-    std::make_pair(node_.id, node_.mangledNameHash)).second;
-}
-
-std::uint64_t MangledNameCache::at(const model::CppAstNodeId& id_) const
-{
-  std::lock_guard<std::mutex> guard(_cacheMutex);
-  return _mangledNameCache.at(id_);
-}
-
-void MangledNameCache::clear()
-{
-  _mangledNameCache.clear();
-}
-
-}
-}
diff --git a/plugins/cpp/parser/src/ppincludecallback.cpp b/plugins/cpp/parser/src/ppincludecallback.cpp
index 3d75c1540..b163732fe 100644
--- a/plugins/cpp/parser/src/ppincludecallback.cpp
+++ b/plugins/cpp/parser/src/ppincludecallback.cpp
@@ -13,13 +13,13 @@ namespace parser
 PPIncludeCallback::PPIncludeCallback(
   ParserContext& ctx_,
   clang::ASTContext& astContext_,
-  MangledNameCache& mangledNameCache_,
+  EntityCache& entityCache_,
   clang::Preprocessor&) :
     _ctx(ctx_),
     _cppSourceType("CPP"),
     _clangSrcMgr(astContext_.getSourceManager()),
     _fileLocUtil(astContext_.getSourceManager()),
-    _mangledNameCache(mangledNameCache_)
+    _entityCache(entityCache_)
 {
 }
 
@@ -40,7 +40,7 @@ model::CppAstNodePtr PPIncludeCallback::createFileAstNode(
   model::CppAstNodePtr astNode(new model::CppAstNode());
 
   astNode->astValue = file_->path;
-  astNode->mangledNameHash = util::fnvHash(std::to_string(file_->id));
+  astNode->entityHash = util::fnvHash(std::to_string(file_->id));
   astNode->symbolType = model::CppAstNode::SymbolType::File;
   astNode->astType = model::CppAstNode::AstType::Usage;
 
@@ -102,7 +102,7 @@ void PPIncludeCallback::InclusionDirective(
   model::CppAstNodePtr fileNode =
     createFileAstNode(included, filenameRange_.getAsRange());
 
-  if (_mangledNameCache.insert(*fileNode))
+  if (_entityCache.insert(*fileNode))
     _astNodes.push_back(fileNode);
 
   model::CppHeaderInclusionPtr inclusion(new model::CppHeaderInclusion);
diff --git a/plugins/cpp/parser/src/ppincludecallback.h b/plugins/cpp/parser/src/ppincludecallback.h
index d4424bc7f..df3a96676 100644
--- a/plugins/cpp/parser/src/ppincludecallback.h
+++ b/plugins/cpp/parser/src/ppincludecallback.h
@@ -14,7 +14,7 @@
 
 #include <util/logutil.h>
 
-#include "manglednamecache.h"
+#include "entitycache.h"
 
 namespace cc
 {
@@ -27,7 +27,7 @@ class PPIncludeCallback : public clang::PPCallbacks
   PPIncludeCallback(
     ParserContext& ctx_,
     clang::ASTContext& astContext_,
-    MangledNameCache& mangledNameCache_,
+    EntityCache& entityCache_,
     clang::Preprocessor& pp_);
 
   ~PPIncludeCallback();
@@ -56,7 +56,7 @@ class PPIncludeCallback : public clang::PPCallbacks
   const std::string _cppSourceType;
   const clang::SourceManager& _clangSrcMgr;
   FileLocUtil _fileLocUtil;
-  MangledNameCache& _mangledNameCache;
+  EntityCache& _entityCache;
 
   std::vector<model::CppAstNodePtr>         _astNodes;
   std::vector<model::CppHeaderInclusionPtr> _headerIncs;
diff --git a/plugins/cpp/parser/src/ppmacrocallback.cpp b/plugins/cpp/parser/src/ppmacrocallback.cpp
index 95ac46792..d86532e32 100644
--- a/plugins/cpp/parser/src/ppmacrocallback.cpp
+++ b/plugins/cpp/parser/src/ppmacrocallback.cpp
@@ -13,14 +13,14 @@ namespace parser
 PPMacroCallback::PPMacroCallback(
   ParserContext& ctx_,
   clang::ASTContext& astContext_,
-  MangledNameCache& mangledNameCache_,
+  EntityCache& entityCache_,
   clang::Preprocessor& pp_) :
     _ctx(ctx_),
     _pp(pp_),
     _cppSourceType("CPP"),
     _clangSrcMgr(astContext_.getSourceManager()),
     _fileLocUtil(astContext_.getSourceManager()),
-    _mangledNameCache(mangledNameCache_)
+    _entityCache(entityCache_)
 {
 }
 
@@ -50,7 +50,7 @@ void PPMacroCallback::MacroExpands(
 
   const clang::MacroInfo* mi = md_.getMacroInfo();
 
-  if (!mi || getMangledName(mi).empty())
+  if (!mi || getUSR(mi).empty())
     return;
 
   const char* begin = _clangSrcMgr.getCharacterData(range_.getBegin());
@@ -136,7 +136,7 @@ void PPMacroCallback::MacroExpands(
   addFileLoc(astNode, macroNameTok_.getLocation(), macroNameTok_.getLastLoc());
   astNode->id = model::createIdentifier(*astNode);
 
-  if (_mangledNameCache.insert(*astNode))
+  if (_entityCache.insert(*astNode))
   {
     _astNodes.push_back(astNode);
 
@@ -154,7 +154,7 @@ void PPMacroCallback::MacroDefined(
 {
   const clang::MacroInfo* mi = md_->getMacroInfo();
 
-  if (!mi || isBuiltInMacro(mi) || getMangledName(mi).empty())
+  if (!mi || isBuiltInMacro(mi) || getUSR(mi).empty())
     return;
 
   model::CppAstNodePtr astNode = createMacroAstNode(macroNameTok_, mi);
@@ -162,13 +162,13 @@ void PPMacroCallback::MacroDefined(
   addFileLoc(astNode, mi->getDefinitionLoc(), mi->getDefinitionEndLoc());
   astNode->id = model::createIdentifier(*astNode);
 
-  if (_mangledNameCache.insert(*astNode))
+  if (_entityCache.insert(*astNode))
   {
     _astNodes.push_back(astNode);
 
     model::CppMacroPtr macro = std::make_shared<model::CppMacro>();
     macro->astNodeId = astNode->id;
-    macro->mangledNameHash = astNode->mangledNameHash;
+    macro->entityHash = astNode->entityHash;
     macro->name = astNode->astValue;
     macro->qualifiedName = astNode->astValue;
     _macros.push_back(macro);
@@ -182,7 +182,7 @@ void PPMacroCallback::MacroUndefined(
 {
   const clang::MacroInfo* mi = md_.getMacroInfo();
 
-  if (!mi || isBuiltInMacro(mi) || getMangledName(mi).empty())
+  if (!mi || isBuiltInMacro(mi) || getUSR(mi).empty())
     return;
 
   auto astNode = createMacroAstNode(macroNameTok_, mi);
@@ -190,7 +190,7 @@ void PPMacroCallback::MacroUndefined(
   addFileLoc(astNode, macroNameTok_.getLocation(), macroNameTok_.getLastLoc());
   astNode->id = model::createIdentifier(*astNode);
 
-  if (_mangledNameCache.insert(*astNode))
+  if (_entityCache.insert(*astNode))
     _astNodes.push_back(astNode);
 }
 
@@ -201,7 +201,7 @@ model::CppAstNodePtr PPMacroCallback::createMacroAstNode(
   model::CppAstNodePtr astNode(new model::CppAstNode);
 
   astNode->astValue = macroNameTok_.getIdentifierInfo()->getName().str();
-  astNode->mangledNameHash = util::fnvHash(getMangledName(mi_));
+  astNode->entityHash = util::fnvHash(getUSR(mi_));
   astNode->symbolType = model::CppAstNode::SymbolType::Macro;
 
   return astNode;
@@ -242,7 +242,7 @@ bool PPMacroCallback::isBuiltInMacro(const clang::MacroInfo* mi_) const
   return fileName == "<built-in>" || fileName == "<command line>";
 }
 
-std::string PPMacroCallback::getMangledName(const clang::MacroInfo* mi_)
+std::string PPMacroCallback::getUSR(const clang::MacroInfo* mi_)
 {
   clang::PresumedLoc presLoc = _clangSrcMgr.getPresumedLoc(
     _clangSrcMgr.getExpansionLoc(mi_->getDefinitionLoc()));
diff --git a/plugins/cpp/parser/src/ppmacrocallback.h b/plugins/cpp/parser/src/ppmacrocallback.h
index 5a7a89ae5..224cfe27b 100644
--- a/plugins/cpp/parser/src/ppmacrocallback.h
+++ b/plugins/cpp/parser/src/ppmacrocallback.h
@@ -16,7 +16,7 @@
 
 #include <util/logutil.h>
 
-#include "manglednamecache.h"
+#include "entitycache.h"
 
 namespace cc
 {
@@ -29,7 +29,7 @@ class PPMacroCallback : public clang::PPCallbacks
   PPMacroCallback(
     ParserContext& ctx_,
     clang::ASTContext& astContext_,
-    MangledNameCache& mangledNameCache_,
+    EntityCache& entityCache_,
     clang::Preprocessor& pp_);
 
   ~PPMacroCallback();
@@ -64,9 +64,13 @@ class PPMacroCallback : public clang::PPCallbacks
   bool isBuiltInMacro(const clang::MacroInfo* mi_) const;
 
   /**
-   * This function returns the mangled name of the macro.
+   * This function returns a unique identifier of the macro.
+   *
+   * TODO: In Clang there is a function named generateUSRForMacro(), but we're
+   * not using that in this implementation. That function gets a
+   * MacroDefinitionRecord as parameter, but here we have a MacroInfo.
    */
-  std::string getMangledName(const clang::MacroInfo *MI);
+  std::string getUSR(const clang::MacroInfo *MI);
 
   /**
    * This function add fill the file location of the AST node.
@@ -84,7 +88,7 @@ class PPMacroCallback : public clang::PPCallbacks
 
   bool _disabled = false;
 
-  MangledNameCache& _mangledNameCache;
+  EntityCache& _entityCache;
   std::vector<model::CppAstNodePtr>        _astNodes;
   std::vector<model::CppMacroPtr>          _macros;
   std::vector<model::CppMacroExpansionPtr> _macrosExpansion;
diff --git a/plugins/cpp/parser/src/symbolhelper.cpp b/plugins/cpp/parser/src/symbolhelper.cpp
index 44c317c9a..4d4d05f8d 100644
--- a/plugins/cpp/parser/src/symbolhelper.cpp
+++ b/plugins/cpp/parser/src/symbolhelper.cpp
@@ -3,6 +3,7 @@
 #include <clang/AST/ASTContext.h>
 #include <clang/AST/Decl.h>
 #include <clang/AST/DeclCXX.h>
+#include <clang/Index/USRGeneration.h>
 #include <clang/Lex/Lexer.h>
 
 #include <model/fileloc.h>
@@ -14,17 +15,6 @@
 namespace
 {
 
-std::string getSuffixFromLoc(const cc::model::FileLoc& fileLoc_)
-{
-  if (!fileLoc_.file)
-    return std::string();
-
-  return
-      std::to_string(fileLoc_.file.object_id()) + ':'
-    + std::to_string(fileLoc_.range.start.line) + ':'
-    + std::to_string(fileLoc_.range.start.column);
-}
-
 /**
  * This function removes the first occurence of what_ in str_ if any.
  */
@@ -66,146 +56,54 @@ const clang::Type* getStrippedType(const clang::QualType& qt_)
   return type;
 }
 
-std::string getMangledName(
-  clang::MangleContext* mangleContext_,
-  const clang::NamedDecl* nd_,
-  const model::FileLoc& fileLoc_)
+std::string getUSR(const clang::NamedDecl* nd_)
 {
-  if (const clang::VarDecl* vd = llvm::dyn_cast<clang::VarDecl>(nd_))
-  {
-    std::string result = nd_->getQualifiedNameAsString();
-
-    if (const clang::DeclContext* dc = nd_->getParentFunctionOrMethod())
-    {
-      // Fixes issue #415 of parser segfaults.
-      // https://github.com/Ericsson/CodeCompass/issues/415
-      //
-      // There are contexts in which getParentFunctionOrMethod() is not
-      // null, but the result is not FunctionDecl (such as CapturedDecl),
-      // e.g. when the to-be-mangled node is inside an OMP block.
-      // In that case, try to find some parent DeclContext we can
-      // reasonably mangle.
-      while (!llvm::isa<clang::FunctionDecl>(dc) &&
-        !llvm::isa<clang::TranslationUnitDecl>(dc))
-      {
-        LOG(debug) << "Yet another getparentFunctionMethod() && "
-          "! llvm::dyn_cast<clang::FunctionDecl>(dc) ";
-        LOG(debug) << dc->getDeclKindName();
-
-        dc = dc->getLookupParent();
-      }
-
-      if (const auto* dcfd = llvm::dyn_cast<clang::FunctionDecl>(dc))
-        result += ':' + getMangledName(mangleContext_, dcfd);
-      else if (llvm::isa<clang::TranslationUnitDecl>(dc))
-        result += ':' + std::to_string(fileLoc_.file.object_id());
-
-      if (const clang::ParmVarDecl* pvd =
-          llvm::dyn_cast<clang::ParmVarDecl>(nd_))
-        result += ':' + std::to_string(pvd->getFunctionScopeIndex());
-    }
-
-    if (vd->isLocalVarDecl() || llvm::isa<clang::ParmVarDecl>(nd_))
-      result += ':' + getSuffixFromLoc(fileLoc_);
-
-    return result;
-  }
-  else if (llvm::isa<clang::NamespaceDecl>(nd_))
-  {
-    const clang::NamespaceDecl* na_ = llvm::dyn_cast<clang::NamespaceDecl>(nd_);
-    return na_->isAnonymousNamespace()
-      ? "anonymous-ns:" + std::to_string(fileLoc_.file.object_id())
-      : nd_->getQualifiedNameAsString();
-  }
-  else if (const clang::CXXRecordDecl* rd
-    = llvm::dyn_cast<clang::CXXRecordDecl>(nd_))
-  {
-    // AST nodes of type CXXRecordDecl contain another CXXRecordDecl node. The
-    // outer one is for the definition (and its position is the whole
-    // definition) and the inner one is for a declaration (of which the position
-    // is the "class" keyword and the class name.
-    // The qualified name of the inner node is ClassName::ClassName, although we
-    // should choose the same mangled name i.e. the qualified name of its
-    // parent.
-
-    const clang::CXXRecordDecl* parent
-      = llvm::dyn_cast<clang::CXXRecordDecl>(rd->getParent());
-
-    return parent && parent->getName() == rd->getName()
-      ? parent->getQualifiedNameAsString()
-      : rd->getQualifiedNameAsString();
-  }
-
-  // TODO: For some reason some named decls don't have name.
-  // Function parameters without name (e.g. compiler generated functions) don't
-  // have a name, but we can generate them a unique name later.
-  if (nd_->getNameAsString().empty() && !llvm::isa<clang::FunctionDecl>(nd_))
-    return nd_->getQualifiedNameAsString();
-
-  // No need to mangle C sources or declarations in extern "C".
-  if (!mangleContext_->shouldMangleDeclName(nd_))
-    return nd_->getQualifiedNameAsString();
-
-  const clang::FunctionDecl* fd = llvm::dyn_cast<clang::FunctionDecl>(nd_);
-  if (fd && llvm::isa<clang::FunctionProtoType>(
-    fd->getType()->getAs<clang::FunctionType>()))
-  {
-    // FIXME: Workaround for a crash reported in #236
-    // From Clang's code:
-    // We should never mangle anything without a prototype.
-
-    std::string str;
-    llvm::raw_string_ostream out(str);
-
-    if (const clang::CXXConstructorDecl* ctor
-        = llvm::dyn_cast<clang::CXXConstructorDecl>(fd))
-      mangleContext_->mangleCXXCtor(ctor, clang::Ctor_Complete, out);
-    else if (const clang::CXXDestructorDecl* dtor
-        = llvm::dyn_cast<clang::CXXDestructorDecl>(fd))
-      mangleContext_->mangleCXXDtor(dtor, clang::Dtor_Complete, out);
-    else
-      mangleContext_->mangleName(fd, out);
-    
-    // TODO: In the case when a function has a template and a non-template
-    // version then their mangled name is the same as long as the template is
-    // not instantiated. Distinguising them by their locations is not good,
-    // because if there is a function which has two versions in an #ifdef ...
-    // #else ... #endif section then every usage will also have two versions.
-    // So if a function has a template and a non-template version at the same
-    // time then querying the definition of the non-template usage the template
-    // version also returns.
-    return out.str();
-  }
-
-  return nd_->getQualifiedNameAsString();
+  // Function generateUSRForDecl() returns a boolean value which indicates
+  // whether the generated USR should be ignored or not. It is easily seen in
+  // the implementation when this boolean is true:
+  // https://clang.llvm.org/doxygen/USRGeneration_8cpp_source.html
+  // Just search for "IgnoreResults" variable and see where it's set true.
+  // Some examples are the AST node for linkage specifiers (i.e. extern "C"),
+  // the "using" directive, and some unnamed symbols, like the parameter of
+  // this function pointer: void (*f)(int);
+  // This last one is important from CodeCompass point of view: we store a
+  // CppEntity in the database for the parameter variable of this function
+  // declaration, however, according to Clang documentation the generated USR
+  // for this node is supposed to be ignored. I can't see why the generation of
+  // this USR can't be finished. Maybe it is not possible to distinguish this
+  // node from another one we don't know about. Anyway, the generated USR is
+  // good enough for us to identify this unnamed variable, because according to
+  // our experiences it is quite unique and the variable can't be clicked on
+  // the GUI (since it has no name to click on).
+  // So far I have met only one case when an USR which is supposed to be
+  // ignored is not good enough: the unnamed parameter of a compiler-generated
+  // copy/move constructor and assignment operator. The USR of these parameters
+  // is the same as the USR of these functions themselves.
+  // So skipping the return value of generateUSRForDecl() is a conscious
+  // choice.
+  llvm::SmallVector<char, 64> usr;
+  clang::index::generateUSRForDecl(nd_, usr);
+  char* data = usr.data();
+  return std::string(data, data + usr.size());
 }
 
-std::string getMangledName(
-  clang::MangleContext* mangleContext_,
-  const clang::QualType& qt_,
-  const model::FileLoc& fileLoc_)
+std::string getUSR(const clang::QualType& qt_, clang::ASTContext& ctx_)
 {
-  const clang::Type* type = getStrippedType(qt_);
-
-  // TODO: How can this happen?
-  if (!type)
-    return std::string();
+  const clang::Type* type = qt_.getTypePtr();
 
-  // TODO: What about primitive types?
   if (const clang::TypedefType* td = type->getAs<clang::TypedefType>())
   {
     if (const clang::TypedefNameDecl* tDecl = td->getDecl())
-      return getMangledName(mangleContext_, tDecl, fileLoc_);
+      return getUSR(tDecl);
   }
-  else if (const clang::CXXRecordDecl* rDecl = type->getAsCXXRecordDecl())
-    return getMangledName(mangleContext_, rDecl);
-  else if (const clang::EnumType* et = type->getAs<clang::EnumType>())
-    if (const clang::Decl* decl = et->getDecl())
-      return getMangledName(
-        mangleContext_,
-        llvm::dyn_cast<clang::NamedDecl>(decl));
-
-  return std::string();
+  else if (const clang::TagDecl* tDecl = type->getAsTagDecl())
+    return getUSR(tDecl);
+
+  // This is supposed to run only for base types.
+  llvm::SmallVector<char, 64> usr;
+  clang::index::generateUSRForType(qt_, ctx_, usr);
+  char* data = usr.data();
+  return std::string(data, data + usr.size());
 }
 
 bool isFunction(const clang::Type* type_)
diff --git a/plugins/cpp/parser/src/symbolhelper.h b/plugins/cpp/parser/src/symbolhelper.h
index 8a7a6037e..97f90544b 100644
--- a/plugins/cpp/parser/src/symbolhelper.h
+++ b/plugins/cpp/parser/src/symbolhelper.h
@@ -16,15 +16,8 @@ namespace parser
 
 const clang::Type* getStrippedType(const clang::QualType& qt_);
 
-std::string getMangledName(
-  clang::MangleContext* mangleContext_,
-  const clang::NamedDecl* nd_,
-  const model::FileLoc& fileLoc_ = model::FileLoc());
-
-std::string getMangledName(
-  clang::MangleContext* mangleContext_,
-  const clang::QualType& qt_,
-  const model::FileLoc& fileLoc_ = model::FileLoc());
+std::string getUSR(const clang::NamedDecl* nd_);
+std::string getUSR(const clang::QualType& qt_, clang::ASTContext& ctx_);
 
 bool isFunction(const clang::Type* type_);
 
diff --git a/plugins/cpp/service/include/service/cppservice.h b/plugins/cpp/service/include/service/cppservice.h
index 79f19dfee..edfc3bbfc 100644
--- a/plugins/cpp/service/include/service/cppservice.h
+++ b/plugins/cpp/service/include/service/cppservice.h
@@ -145,9 +145,7 @@ class CppServiceHandler : virtual public LanguageServiceIf
       queried. */
 
     USAGE, /*!< By this option the usages of the AST node can be queried, i.e.
-      the nodes of which the mangled name is identical to the queried one. The
-      parser creates a mangled name even for variables and types, which is
-      unique for the element. */
+      the nodes of which the entity hash is identical to the queried one. */
 
     THIS_CALLS, /*!< Get function calls in a function. WARNING: If the
       definition of the AST node is not unique then it returns the callees of
@@ -279,7 +277,7 @@ class CppServiceHandler : virtual public LanguageServiceIf
 
   /**
    * This function returns the model::CppAstNode objects which meet the
-   * requirements of the given query and have the same mangled name as the given
+   * requirements of the given query and have the same entity hash as the given
    * AST node.
    */
   std::vector<model::CppAstNode> queryCppAstNodes(
@@ -307,7 +305,7 @@ class CppServiceHandler : virtual public LanguageServiceIf
 
   /**
    * This function returns the model::CppAstNode objects which have the same
-   * mangled name as the given astNodeId_ and have
+   * entity hash as the given astNodeId_ and have
    * model::CppAstNode::AstType::Definition type. Unfortunately the definition
    * of an entity is not unequivocal, since in different translation units
    * different definitions may occure for example because of an #ifdef block.
diff --git a/plugins/cpp/service/src/cppservice.cpp b/plugins/cpp/service/src/cppservice.cpp
index c4848fd35..a54e759cb 100644
--- a/plugins/cpp/service/src/cppservice.cpp
+++ b/plugins/cpp/service/src/cppservice.cpp
@@ -81,7 +81,7 @@ namespace
       cc::service::language::AstNodeInfo ret;
 
       ret.__set_id(std::to_string(astNode_.id));
-      ret.__set_mangledNameHash(astNode_.mangledNameHash);
+      ret.__set_entityHash(astNode_.entityHash);
       ret.__set_astNodeType(cc::model::astTypeToString(astNode_.astType));
       ret.__set_symbolType(cc::model::symbolTypeToString(astNode_.symbolType));
       ret.__set_astNodeValue(astNode_.astValue);
@@ -166,7 +166,7 @@ void CppServiceHandler::getDocumentation(
     model::CppAstNode node = queryCppAstNode(astNodeId_);
 
     DocCommentResult docComment = _db->query<model::CppDocComment>(
-      DocCommentQuery::mangledNameHash == node.mangledNameHash);
+      DocCommentQuery::entityHash == node.entityHash);
 
     if (!docComment.empty())
       return_ = "<div class=\"main-doc\">" + docComment.begin()->content
@@ -209,7 +209,7 @@ void CppServiceHandler::getDocumentation(
           //--- Query documentation of members ---//
 
           DocCommentResult doc = _db->query<model::CppDocComment>(
-            DocCommentQuery::mangledNameHash == method.mangledNameHash);
+            DocCommentQuery::entityHash == method.entityHash);
 
           if (!doc.empty())
             return_ += doc.begin()->content;
@@ -279,7 +279,7 @@ void CppServiceHandler::getProperties(
       case model::CppAstNode::SymbolType::Variable:
       {
         VarResult variables = _db->query<model::CppVariable>(
-          VarQuery::mangledNameHash == node.mangledNameHash);
+          VarQuery::entityHash == node.entityHash);
         model::CppVariable variable = *variables.begin();
 
         return_["Name"] = variable.name;
@@ -291,7 +291,7 @@ void CppServiceHandler::getProperties(
       case model::CppAstNode::SymbolType::Function:
       {
         FuncResult functions = _db->query<model::CppFunction>(
-          FuncQuery::mangledNameHash == node.mangledNameHash);
+          FuncQuery::entityHash == node.entityHash);
         model::CppFunction function = *functions.begin();
 
         return_["Name"] = function.qualifiedName.substr(
@@ -305,7 +305,7 @@ void CppServiceHandler::getProperties(
       case model::CppAstNode::SymbolType::Type:
       {
         TypeResult types = _db->query<model::CppRecord>(
-          TypeQuery::mangledNameHash == node.mangledNameHash);
+          TypeQuery::entityHash == node.entityHash);
         model::CppRecord type = *types.begin();
 
         if (type.isAbstract)
@@ -322,7 +322,7 @@ void CppServiceHandler::getProperties(
       case model::CppAstNode::SymbolType::Typedef:
       {
         TypedefResult types = _db->query<model::CppTypedef>(
-          TypedefQuery::mangledNameHash == node.mangledNameHash);
+          TypedefQuery::entityHash == node.entityHash);
         model::CppTypedef type = *types.begin();
 
         return_["Name"] = type.name;
@@ -335,7 +335,7 @@ void CppServiceHandler::getProperties(
       {
         EnumConstResult enumConsts
           = _db->query<model::CppEnumConstant>(
-              EnumConstQuery::mangledNameHash == node.mangledNameHash);
+              EnumConstQuery::entityHash == node.entityHash);
         model::CppEnumConstant enumConst = *enumConsts.begin();
 
         return_["Name"] = enumConst.name;
@@ -382,12 +382,12 @@ std::int32_t CppServiceHandler::getReferenceCount(
         for (const model::CppAstNode& call : queryCalls(astNodeId_))
         {
           model::CppAstNode node = queryCppAstNode(std::to_string(call.id));
-          defHashes.insert(node.mangledNameHash);
+          defHashes.insert(node.entityHash);
         }
 
         if (!defHashes.empty())
           count += _db->query_value<model::CppAstCount>(
-            AstQuery::mangledNameHash.in_range(
+            AstQuery::entityHash.in_range(
               defHashes.begin(), defHashes.end()) &&
             AstQuery::astType == model::CppAstNode::AstType::Definition &&
             AstQuery::location.range.end.line != model::Position::npos).count;
@@ -421,13 +421,13 @@ std::int32_t CppServiceHandler::getReferenceCount(
         std::unordered_set<std::uint64_t> fptrCallers
           = transitiveClosureOfRel(
               model::CppRelation::Kind::Assign,
-              node.mangledNameHash,
+              node.entityHash,
               true);
 
-        for (std::uint64_t mangledNameHash : fptrCallers)
+        for (std::uint64_t entityHash : fptrCallers)
         {
           AstResult result = _db->query<model::CppAstNode>(
-            AstQuery::mangledNameHash == mangledNameHash &&
+            AstQuery::entityHash == entityHash &&
             AstQuery::astType == model::CppAstNode::AstType::Usage);
           count += result.size();
         }
@@ -448,12 +448,12 @@ std::int32_t CppServiceHandler::getReferenceCount(
         node = queryCppAstNode(astNodeId_);
 
         FuncResult functions = _db->query<cc::model::CppFunction>(
-          FuncQuery::mangledNameHash == node.mangledNameHash);
+          FuncQuery::entityHash == node.entityHash);
 
         const model::CppFunction& function = *functions.begin();
 
         return _db->query_value<model::CppRecordCount>(
-          TypeQuery::mangledNameHash == function.typeHash).count;
+          TypeQuery::entityHash == function.typeHash).count;
 
         break;
       }
@@ -477,49 +477,49 @@ std::int32_t CppServiceHandler::getReferenceCount(
         node = queryCppAstNode(astNodeId_);
 
         VarResult varNodes = _db->query<cc::model::CppVariable>(
-          VarQuery::mangledNameHash == node.mangledNameHash);
+          VarQuery::entityHash == node.entityHash);
 
         const model::CppVariable& variable = *varNodes.begin();
 
         return _db->query_value<model::CppRecordCount>(
-          TypeQuery::mangledNameHash == variable.typeHash).count;
+          TypeQuery::entityHash == variable.typeHash).count;
 
         break;
       }
 
       case ALIAS:
         return _db->query_value<model::CppTypedefCount>(
-          TypedefQuery::typeHash == node.mangledNameHash).count;
+          TypedefQuery::typeHash == node.entityHash).count;
 
       case INHERIT_FROM:
         return _db->query_value<model::CppInheritanceCount>(
-          InhQuery::derived == node.mangledNameHash).count;
+          InhQuery::derived == node.entityHash).count;
 
       case INHERIT_BY:
         return _db->query_value<model::CppInheritanceCount>(
-          InhQuery::base == node.mangledNameHash).count;
+          InhQuery::base == node.entityHash).count;
 
       case DATA_MEMBER:
         return _db->query_value<model::CppMemberTypeCount>(
-          MemTypeQuery::typeHash == node.mangledNameHash &&
+          MemTypeQuery::typeHash == node.entityHash &&
           MemTypeQuery::kind == model::CppMemberType::Kind::Field).count;
 
       case METHOD:
         return _db->query_value<model::CppMemberTypeCount>(
-          MemTypeQuery::typeHash == node.mangledNameHash &&
+          MemTypeQuery::typeHash == node.entityHash &&
           MemTypeQuery::kind == model::CppMemberType::Kind::Method).count;
 
       case FRIEND:
         return _db->query_value<model::CppFriendshipCount>(
-          FriendQuery::target == node.mangledNameHash).count;
+          FriendQuery::target == node.entityHash).count;
 
       case UNDERLYING_TYPE:
         return _db->query_value<model::CppTypedefCount>(
-          TypedefQuery::mangledNameHash == node.mangledNameHash).count;
+          TypedefQuery::entityHash == node.entityHash).count;
 
       case ENUM_CONSTANTS:
         return _db->query_value<model::CppEnumConstantsCount>(
-          EnumQuery::mangledNameHash == node.mangledNameHash).count;
+          EnumQuery::entityHash == node.entityHash).count;
 
       case EXPANSION:
         return _db->query_value<model::CppMacroExpansionCount>(
@@ -699,13 +699,13 @@ void CppServiceHandler::getReferences(
         std::unordered_set<std::uint64_t> fptrCallers
           = transitiveClosureOfRel(
               model::CppRelation::Kind::Assign,
-              node.mangledNameHash,
+              node.entityHash,
               true);
 
-        for (std::uint64_t mangledNameHash : fptrCallers)
+        for (std::uint64_t entityHash : fptrCallers)
         {
           AstResult result = _db->query<model::CppAstNode>(
-            AstQuery::mangledNameHash == mangledNameHash &&
+            AstQuery::entityHash == entityHash &&
             AstQuery::astType == model::CppAstNode::AstType::Usage);
           nodes.insert(nodes.end(), result.begin(), result.end());
         }
@@ -718,7 +718,7 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         FuncResult functions = _db->query<model::CppFunction>(
-          FuncQuery::mangledNameHash == node.mangledNameHash);
+          FuncQuery::entityHash == node.entityHash);
         model::CppFunction function = *functions.begin();
 
         for (auto var : function.parameters)
@@ -733,7 +733,7 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         FuncResult functions = _db->query<model::CppFunction>(
-          FuncQuery::mangledNameHash == node.mangledNameHash);
+          FuncQuery::entityHash == node.entityHash);
         model::CppFunction function = *functions.begin();
 
         for (auto var : function.locals)
@@ -748,11 +748,11 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         FuncResult functions = _db->query<model::CppFunction>(
-          FuncQuery::mangledNameHash == node.mangledNameHash);
+          FuncQuery::entityHash == node.entityHash);
         model::CppFunction function = *functions.begin();
 
         TypeResult result = _db->query<model::CppRecord>(
-          TypeQuery::mangledNameHash == function.typeHash);
+          TypeQuery::entityHash == function.typeHash);
 
         for (const model::CppRecord& type : result)
         {
@@ -791,7 +791,7 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         TypedefResult result = _db->query<model::CppTypedef>(
-          TypedefQuery::typeHash == node.mangledNameHash);
+          TypedefQuery::typeHash == node.entityHash);
 
         for (const auto& typeDef : result)
           nodes.push_back(queryCppAstNode(std::to_string(typeDef.astNodeId)));
@@ -804,12 +804,12 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         VarResult varNodes = _db->query<cc::model::CppVariable>(
-          VarQuery::mangledNameHash == node.mangledNameHash);
+          VarQuery::entityHash == node.entityHash);
 
         const model::CppVariable& variable = *varNodes.begin();
 
         TypeResult result = _db->query<model::CppRecord>(
-          TypeQuery::mangledNameHash == variable.typeHash);
+          TypeQuery::entityHash == variable.typeHash);
 
         for (const model::CppRecord& type : result)
         {
@@ -826,10 +826,10 @@ void CppServiceHandler::getReferences(
 
         for (const model::CppInheritance& inh :
           _db->query<model::CppInheritance>(
-            InhQuery::derived == node.mangledNameHash)) // TODO: Filter by tags
+            InhQuery::derived == node.entityHash)) // TODO: Filter by tags
         {
           AstResult result = _db->query<model::CppAstNode>(
-            AstQuery::mangledNameHash == inh.base &&
+            AstQuery::entityHash == inh.base &&
             AstQuery::astType == model::CppAstNode::AstType::Definition);
           nodes.insert(nodes.end(), result.begin(), result.end());
         }
@@ -841,10 +841,10 @@ void CppServiceHandler::getReferences(
 
         for (const model::CppInheritance& inh :
           _db->query<model::CppInheritance>(
-            InhQuery::base == node.mangledNameHash )) // TODO: Filter by tags
+            InhQuery::base == node.entityHash )) // TODO: Filter by tags
         {
           AstResult result = _db->query<model::CppAstNode>(
-            AstQuery::mangledNameHash == inh.derived &&
+            AstQuery::entityHash == inh.derived &&
             AstQuery::astType == model::CppAstNode::AstType::Definition);
           nodes.insert(nodes.end(), result.begin(), result.end());
         }
@@ -855,7 +855,7 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         for (const model::CppMemberType& mem : _db->query<model::CppMemberType>(
-          MemTypeQuery::typeHash == node.mangledNameHash &&
+          MemTypeQuery::typeHash == node.entityHash &&
           MemTypeQuery::kind == model::CppMemberType::Kind::Field))
           // TODO: Filter by tags
         {
@@ -872,7 +872,7 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         for (const model::CppMemberType& mem : _db->query<model::CppMemberType>(
-          MemTypeQuery::typeHash == node.mangledNameHash &&
+          MemTypeQuery::typeHash == node.entityHash &&
           MemTypeQuery::kind == model::CppMemberType::Kind::Method))
           // TODO: Filter by tags
         {
@@ -887,10 +887,10 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         for (const model::CppFriendship& fr : _db->query<model::CppFriendship>(
-          FriendQuery::target == node.mangledNameHash))
+          FriendQuery::target == node.entityHash))
         {
           AstResult result = _db->query<model::CppAstNode>(
-            AstQuery::mangledNameHash == fr.theFriend &&
+            AstQuery::entityHash == fr.theFriend &&
             AstQuery::astType == model::CppAstNode::AstType::Definition);
           nodes.insert(nodes.end(), result.begin(), result.end());
         }
@@ -902,11 +902,11 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         TypedefResult types = _db->query<model::CppTypedef>(
-          TypedefQuery::mangledNameHash == node.mangledNameHash);
+          TypedefQuery::entityHash == node.entityHash);
         model::CppTypedef type = *types.begin();
 
         AstResult result = _db->query<model::CppAstNode>(
-          AstQuery::mangledNameHash == type.typeHash &&
+          AstQuery::entityHash == type.typeHash &&
           AstQuery::astType == model::CppAstNode::AstType::Definition);
 
         nodes = std::vector<model::CppAstNode>(result.begin(), result.end());
@@ -919,7 +919,7 @@ void CppServiceHandler::getReferences(
         node = queryCppAstNode(astNodeId_);
 
         EnumResult cppEnums = _db->query<model::CppEnum>(
-          EnumQuery::mangledNameHash == node.mangledNameHash);
+          EnumQuery::entityHash == node.entityHash);
         model::CppEnum cppEnum = *cppEnums.begin();
 
         std::transform(
@@ -1359,7 +1359,7 @@ std::vector<model::CppAstNode> CppServiceHandler::queryCppAstNodes(
   model::CppAstNode node = queryCppAstNode(astNodeId_);
 
   AstResult result = _db->query<model::CppAstNode>(
-    AstQuery::mangledNameHash == node.mangledNameHash &&
+    AstQuery::entityHash == node.entityHash &&
     AstQuery::location.range.end.line != model::Position::npos &&
     query_);
 
@@ -1439,7 +1439,7 @@ std::vector<model::CppAstNode> CppServiceHandler::queryOverrides(
   std::unordered_set<std::uint64_t> overrides
     = transitiveClosureOfRel(
         model::CppRelation::Kind::Override,
-        node.mangledNameHash,
+        node.entityHash,
         reverse_);
 
   std::transform(
@@ -1448,7 +1448,7 @@ std::vector<model::CppAstNode> CppServiceHandler::queryOverrides(
     std::back_inserter(nodes),
     [this](std::uint64_t mnh){
       AstResult result
-        = _db->query<model::CppAstNode>(AstQuery::mangledNameHash == mnh);
+        = _db->query<model::CppAstNode>(AstQuery::entityHash == mnh);
 
       return *result.begin();
     });
@@ -1524,7 +1524,7 @@ CppServiceHandler::getTags(const std::vector<model::CppAstNode>& nodes_)
         //--- Virtual Tag ---//
 
         FuncResult funcNodes = _db->query<cc::model::CppFunction>(
-          FuncQuery::mangledNameHash == defNode.mangledNameHash);
+          FuncQuery::entityHash == defNode.entityHash);
         const model::CppFunction& funcNode = *funcNodes.begin();
 
         for (const model::Tag& tag : funcNode.tags)
@@ -1551,7 +1551,7 @@ CppServiceHandler::getTags(const std::vector<model::CppAstNode>& nodes_)
         //--- Global Tag ---//
 
         VarResult varNodes = _db->query<cc::model::CppVariable>(
-          VarQuery::mangledNameHash == defNode.mangledNameHash);
+          VarQuery::entityHash == defNode.entityHash);
         const model::CppVariable& varNode = *varNodes.begin();
 
         for (const model::Tag& tag : varNode.tags)
@@ -1572,7 +1572,7 @@ std::size_t CppServiceHandler::queryCppAstNodeCount(
   model::CppAstNode node = queryCppAstNode(astNodeId_);
 
   model::CppAstCount q = _db->query_value<model::CppAstCount>(
-    AstQuery::mangledNameHash == node.mangledNameHash &&
+    AstQuery::entityHash == node.entityHash &&
     AstQuery::location.range.end.line != model::Position::npos &&
     query_);
 
@@ -1586,7 +1586,7 @@ std::size_t CppServiceHandler::queryOverridesCount(
   model::CppAstNode node = queryCppAstNode(astNodeId_);
 
   return transitiveClosureOfRel( model::CppRelation::Kind::Override,
-    node.mangledNameHash, reverse_).size();
+    node.entityHash, reverse_).size();
 }
 
 std::size_t CppServiceHandler::queryCallsCount(
diff --git a/plugins/cpp/test/src/cppparsertest.cpp b/plugins/cpp/test/src/cppparsertest.cpp
index a5ab04c8b..657761500 100644
--- a/plugins/cpp/test/src/cppparsertest.cpp
+++ b/plugins/cpp/test/src/cppparsertest.cpp
@@ -90,7 +90,7 @@ TEST_F(CppParserTest, SimpleFunction)
     model::CppFunction simpleFunc = _db->query_value<model::CppFunction>(
       QCppFunction::name == "singleFunc");
     model::CppAstNode simpleFuncAstNode = _db->query_value<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == simpleFunc.mangledNameHash);
+      QCppAstNode::entityHash == simpleFunc.entityHash);
 
     EXPECT_EQ(simpleFuncAstNode.astValue, "void singleFunc()");
     EXPECT_EQ(
@@ -121,7 +121,7 @@ TEST_F(CppParserTest, FunctionDeclarationOnly)
     model::CppFunction funcDecl = _db->query_value<model::CppFunction>(
       QCppFunction::name == "funcDecl");
     model::CppAstNode funcDeclAstNode = _db->query_value<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == funcDecl.mangledNameHash);
+      QCppAstNode::entityHash == funcDecl.entityHash);
 
     EXPECT_EQ(
       funcDeclAstNode.symbolType,
@@ -138,7 +138,7 @@ TEST_F(CppParserTest, FunctionWithMultipleDeclarations)
     model::CppFunction callee = _db->query_value<model::CppFunction>(
       QCppFunction::name == "multiFunction");
     RCppAstNode multiFuncAstNode = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == callee.mangledNameHash);
+      QCppAstNode::entityHash == callee.entityHash);
 
     int numDecl = 0, numDef = 0, numOther = 0;
     for (const model::CppAstNode& n : multiFuncAstNode)
@@ -161,7 +161,7 @@ TEST_F(CppParserTest, FunctionCall)
     model::CppFunction callee = _db->query_value<model::CppFunction>(
       QCppFunction::name == "callee");
     RCppAstNode astNodes = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == callee.mangledNameHash);
+      QCppAstNode::entityHash == callee.entityHash);
 
     for (const model::CppAstNode& n : astNodes)
       switch (n.location.range.start.line)
@@ -299,7 +299,7 @@ TEST_F(CppParserTest, Typedef)
     model::CppEnum integer = _db->query_value<model::CppEnum>(
       QCppEnum::name == "Integer");
     RCppAstNode astNodes = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == integer.mangledNameHash);
+      QCppAstNode::entityHash == integer.entityHash);
 
     for (const model::CppAstNode& n : astNodes)
     {
@@ -347,7 +347,7 @@ TEST_F(CppParserTest, Record)
     model::CppRecord myClass = _db->query_value<model::CppRecord>(
       QCppRecord::name == "MyClass");
     RCppAstNode astNodes = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == myClass.mangledNameHash);
+      QCppAstNode::entityHash == myClass.entityHash);
 
     for (const model::CppAstNode& n : astNodes)
     {
@@ -357,11 +357,14 @@ TEST_F(CppParserTest, Record)
       {
         case -1: 
           EXPECT_TRUE(
-          // TODO: investigate the type of this. It is possibly the parameter of a
-          // compiler generated copy constructor or assignment operator.
-          // The type should also be visible as a return type of the compiler generated
-          // assignment operator.
+            // TODO: investigate the type of this. It is possibly the parameter
+            // of a compiler generated copy constructor or assignment operator.
+            // ParameterTypeLoc and ReturnTypeLoc are both listed here,
+            // however, only one of them is found. Earlier when we generated
+            // mangled names manually, the function parameter was stored, now
+            // with USRs we have the return type.
             n.astType == model::CppAstNode::AstType::ParameterTypeLoc ||
+            n.astType == model::CppAstNode::AstType::ReturnTypeLoc ||
             n.astType == model::CppAstNode::AstType::TypeLocation);
           break;
 
@@ -450,7 +453,7 @@ TEST_F(CppParserTest, Enum)
     model::CppEnum enumeration = _db->query_value<model::CppEnum>(
       QCppEnum::name == "Enumeration");
     RCppAstNode astNodes = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == enumeration.mangledNameHash);
+      QCppAstNode::entityHash == enumeration.entityHash);
 
     for (const model::CppAstNode& n : astNodes)
     {
@@ -502,7 +505,7 @@ TEST_F(CppParserTest, Enum)
     model::CppEnumConstant first = _db->query_value<model::CppEnumConstant>(
       QCppEnumConstant::name == "First");
     astNodes = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == first.mangledNameHash);
+      QCppAstNode::entityHash == first.entityHash);
 
     for (const model::CppAstNode& n : astNodes)
     {
@@ -527,7 +530,7 @@ TEST_F(CppParserTest, Enum)
     model::CppFunction fieldFunction = _db->query_value<model::CppFunction>(
       QCppFunction::name == "fieldFunction");
     astNodes = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == fieldFunction.mangledNameHash);
+      QCppAstNode::entityHash == fieldFunction.entityHash);
 
     for (const model::CppAstNode& n : astNodes)
     {
@@ -552,7 +555,7 @@ TEST_F(CppParserTest, Enum)
     model::CppVariable fieldVariable = _db->query_value<model::CppVariable>(
       QCppVariable::name == "fieldVariable");
     astNodes = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == fieldVariable.mangledNameHash);
+      QCppAstNode::entityHash == fieldVariable.entityHash);
 
     for (const model::CppAstNode& n : astNodes)
     {
@@ -583,7 +586,7 @@ TEST_F(CppParserTest, Variable)
       = _db->query_value<model::CppVariable>(
         QCppVariable::name == "variableDefinition");
     RCppAstNode astNodes = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == variableDefinition.mangledNameHash);
+      QCppAstNode::entityHash == variableDefinition.entityHash);
 
     for (const model::CppAstNode& n : astNodes)
       switch (n.location.range.start.line)
@@ -612,7 +615,7 @@ TEST_F(CppParserTest, Variable)
       = _db->query_value<model::CppVariable>(
         QCppVariable::name == "variableDeclaration");
     model::CppAstNode astNode = _db->query_value<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == variableDeclaration.mangledNameHash);
+      QCppAstNode::entityHash == variableDeclaration.entityHash);
 
     EXPECT_EQ(astNode.location.range.start.line, 9);
     EXPECT_EQ(astNode.symbolType, model::CppAstNode::SymbolType::Variable);
@@ -622,7 +625,7 @@ TEST_F(CppParserTest, Variable)
       = _db->query_value<model::CppVariable>(
         QCppVariable::name == "variableFunctionPointer");
     astNode = _db->query_value<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == variableFunctionPointer.mangledNameHash);
+      QCppAstNode::entityHash == variableFunctionPointer.entityHash);
 
     EXPECT_EQ(astNode.location.range.start.line, 10);
     EXPECT_EQ(astNode.symbolType, model::CppAstNode::SymbolType::FunctionPtr);
@@ -631,7 +634,7 @@ TEST_F(CppParserTest, Variable)
     model::CppVariable memberVariable = _db->query_value<model::CppVariable>(
       QCppVariable::name == "memberVariable");
     astNodes = _db->query<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == memberVariable.mangledNameHash);
+      QCppAstNode::entityHash == memberVariable.entityHash);
 
     for (const model::CppAstNode& n : astNodes)
       switch (n.location.range.start.line)
@@ -662,7 +665,7 @@ TEST_F(CppParserTest, Namespace)
     model::CppNamespace myNamespace1 = _db->query_value<model::CppNamespace>(
       QCppNamespace::name == "MyNamespace1");
     model::CppAstNode astNode = _db->query_value<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == myNamespace1.mangledNameHash);
+      QCppAstNode::entityHash == myNamespace1.entityHash);
 
     EXPECT_EQ(astNode.symbolType, model::CppAstNode::SymbolType::Namespace);
     EXPECT_EQ(astNode.location.range.start.line, 1);
@@ -671,7 +674,7 @@ TEST_F(CppParserTest, Namespace)
     model::CppNamespace myNamespace2 = _db->query_value<model::CppNamespace>(
       QCppNamespace::name == "MyNamespace2");
     astNode = _db->query_value<model::CppAstNode>(
-      QCppAstNode::mangledNameHash == myNamespace2.mangledNameHash);
+      QCppAstNode::entityHash == myNamespace2.entityHash);
 
     EXPECT_EQ(astNode.symbolType, model::CppAstNode::SymbolType::Namespace);
     EXPECT_EQ(astNode.location.range.start.line, 3);
diff --git a/plugins/cpp/webgui/js/cppInfoTree.js b/plugins/cpp/webgui/js/cppInfoTree.js
index b08828e69..e112f40b4 100644
--- a/plugins/cpp/webgui/js/cppInfoTree.js
+++ b/plugins/cpp/webgui/js/cppInfoTree.js
@@ -195,8 +195,7 @@ function (model, viewHandler, util) {
                       refTypes['This calls']);
 
                     calls.forEach(function (call) {
-                      if (call.mangledNameHash ===
-                          nodeInfo.mangledNameHash)
+                      if (call.entityHash === nodeInfo.entityHash)
                         res.push({
                           name        : createLabel(call),
                           refType     : parentNode.refType,
diff --git a/service/language/language.thrift b/service/language/language.thrift
index 0acc05c7a..91591abe8 100644
--- a/service/language/language.thrift
+++ b/service/language/language.thrift
@@ -6,7 +6,7 @@ namespace cpp cc.service.language
 struct AstNodeInfo
 {
   1:common.AstNodeId id /** Unique id of the AST node for the whole workspace. */
-  2:i64    mangledNameHash /** To resolve unique names of the AST node. */
+  2:i64    entityHash /** To resolve unique names of the AST node. */
   3:string astNodeType /** String representation of AST type (e.g. Statement/Declaration/Usage). */
   4:string symbolType /** String representation of Symbol type (e.g. Function/Type/Variable). */
   5:string astNodeValue /** String representation of an AST node. */
diff --git a/webserver/include/webserver/thrifthandler.h b/webserver/include/webserver/thrifthandler.h
index 46ac43e28..173e850db 100644
--- a/webserver/include/webserver/thrifthandler.h
+++ b/webserver/include/webserver/thrifthandler.h
@@ -13,32 +13,6 @@
 
 #include "mongoose.h"
 
-/**
- * Returns the demangled name of the type described by the given type info.
- *
- * @param info_ a type info.
- * @return the pretty name of the type.
- */
-inline std::string getTypeName(const std::type_info& info_)
-{
-  int status = 0;
-  std::unique_ptr<char[], void (*)(void*)> result(
-    abi::__cxa_demangle(info_.name(), 0, 0, &status), std::free);
-
-  return result.get() ? std::string(result.get()) : "##error##";
-}
-
-/**
- * Returns the template argument's demangled name.
- *
- * @return the pretty name of the T type.
- */
-template <typename T>
-inline std::string getTypeName()
-{
-  return getTypeName(typeid(T));
-}
-
 namespace cc
 {
 namespace webserver