ynkmr/Sourcetrail
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

logic: fixed filepaths to always use a canonical casing (issue #516)

Browse Source 
* added CanonicalFilePathCache to also reserve the initially recorded casing of file names
* use canonical file path cache to resolve filepaths in names of symbols (anonymous, static, ...)
* null reference fixes
This commit is contained in:
mlangkabel
2017-11-12 16:29:12 +01:00
parent 85207c6355
commit 6488c6538e
88 changed files with 277 additions and 3151 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib_cxx/data/parser/cxx/name_resolver/CxxDeclNameResolver.cpp
+40 -41
View File
@@ -9,18 +9,23 @@
#include "data/parser/cxx/name_resolver/CxxSpecifierNameResolver.h"
#include "data/parser/cxx/name_resolver/CxxTemplateArgumentNameResolver.h"
#include "data/parser/cxx/name_resolver/CxxTypeNameResolver.h"
#include "data/parser/cxx/CanonicalFilePathCache.h"
#include "data/parser/cxx/utilityClang.h"
#include "utility/file/FilePath.h"
#include "utility/ScopedSwitcher.h"
#include "utility/utilityString.h"
CxxDeclNameResolver::CxxDeclNameResolver()
: CxxNameResolver(std::vector<const clang::Decl*>())
CxxDeclNameResolver::CxxDeclNameResolver(std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache)
: CxxNameResolver(canonicalFilePathCache, std::vector<const clang::Decl*>())
, m_currentDecl(nullptr)
{
}
CxxDeclNameResolver::CxxDeclNameResolver(std::vector<const clang::Decl*> ignoredContextDecls)
: CxxNameResolver(ignoredContextDecls)
CxxDeclNameResolver::CxxDeclNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
)
: CxxNameResolver(canonicalFilePathCache, ignoredContextDecls)
, m_currentDecl(nullptr)
{
}
@@ -69,7 +74,7 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getName(const clang::NamedDecl
{
if (const clang::UsingDecl* usingDecl = clang::dyn_cast_or_null<clang::UsingDecl>(declaration))
{
CxxSpecifierNameResolver specifierNameResolver(getIgnoredContextDecls());
CxxSpecifierNameResolver specifierNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
declName->setParent(specifierNameResolver.getName(usingDecl->getQualifier()));
}
else
@@ -127,9 +132,6 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
}
else if (declNameString.empty())
{
const clang::SourceManager& sourceManager = declaration->getASTContext().getSourceManager();
const clang::PresumedLoc& presumedBegin = sourceManager.getPresumedLoc(declaration->getLocStart());
std::string symbolKindName = "class";
if (recordDecl->isStruct())
{
@@ -140,7 +142,7 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
symbolKindName = "union";
}
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol(symbolKindName, presumedBegin), std::vector<std::string>());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol(symbolKindName, declaration), std::vector<std::string>());
}
else if (const clang::CXXRecordDecl* cxxRecordDecl = clang::dyn_cast_or_null<clang::CXXRecordDecl>(declaration))
{
@@ -244,7 +246,7 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
isStatic = functionDecl->getStorageClass() == clang::SC_Static;
}
CxxTypeNameResolver typenNameResolver(getIgnoredContextDecls());
CxxTypeNameResolver typenNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
typenNameResolver.ignoreContextDecl(functionDecl);
std::shared_ptr<CxxTypeName> returnTypeName = CxxTypeName::makeUnsolvedIfNull(typenNameResolver.getName(functionDecl->getReturnType()));
@@ -261,7 +263,7 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
templateArguments,
returnTypeName,
parameterTypeNames,
getTranslationUnitMainFilePath(declaration).fileName()
getTranslationUnitMainFileName(declaration)
);
}
@@ -287,22 +289,18 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
else if (clang::isa<clang::FieldDecl>(declaration))
{
const clang::FieldDecl* fieldDecl = clang::dyn_cast<clang::FieldDecl>(declaration);
CxxTypeNameResolver typenNameResolver(getIgnoredContextDecls());
CxxTypeNameResolver typenNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
typenNameResolver.ignoreContextDecl(fieldDecl);
std::shared_ptr<CxxTypeName> typeName = CxxTypeName::makeUnsolvedIfNull(typenNameResolver.getName(fieldDecl->getType()));
return std::make_shared<CxxVariableDeclName>(declNameString, std::vector<std::string>(), typeName, false);
}
else if (clang::isa<clang::NamespaceDecl>(declaration) && clang::dyn_cast<clang::NamespaceDecl>(declaration)->isAnonymousNamespace())
{
const clang::SourceManager& sourceManager = declaration->getASTContext().getSourceManager();
const clang::PresumedLoc& presumedBegin = sourceManager.getPresumedLoc(declaration->getLocStart());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("namespace", presumedBegin), std::vector<std::string>());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("namespace", declaration), std::vector<std::string>());
}
else if (clang::isa<clang::EnumDecl>(declaration) && declNameString.empty())
{
const clang::SourceManager& sourceManager = declaration->getASTContext().getSourceManager();
const clang::PresumedLoc& presumedBegin = sourceManager.getPresumedLoc(declaration->getLocStart());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("enum", presumedBegin), std::vector<std::string>());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("enum", declaration), std::vector<std::string>());
}
else if (
(
@@ -311,15 +309,11 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
clang::isa<clang::TemplateTemplateParmDecl>(declaration)
) && declNameString.empty())
{
const clang::SourceManager& sourceManager = declaration->getASTContext().getSourceManager();
const clang::PresumedLoc& presumedBegin = sourceManager.getPresumedLoc(declaration->getLocStart());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("template parameter", presumedBegin), std::vector<std::string>());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("template parameter", declaration), std::vector<std::string>());
}
else if (clang::isa<clang::ParmVarDecl>(declaration) && declNameString.empty())
{
const clang::SourceManager& sourceManager = declaration->getASTContext().getSourceManager();
const clang::PresumedLoc& presumedBegin = sourceManager.getPresumedLoc(declaration->getLocStart());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("parameter", presumedBegin), std::vector<std::string>());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("parameter", declaration), std::vector<std::string>());
}
else if (clang::isa<clang::VarDecl>(declaration))
{
@@ -337,7 +331,7 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
// nothing todo, varDecl is global (and non-static)
}
CxxTypeNameResolver typenNameResolver(getIgnoredContextDecls());
CxxTypeNameResolver typenNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
typenNameResolver.ignoreContextDecl(varDecl);
std::shared_ptr<CxxTypeName> typeName = CxxTypeName::makeUnsolvedIfNull(typenNameResolver.getName(varDecl->getType()));
@@ -353,11 +347,11 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
{
if (varDecl->getType().isConstQualified())
{
scopeFileName = getDeclarationFilePath(declaration).fileName();
scopeFileName = getDeclarationFileName(declaration);
}
else
{
scopeFileName = getTranslationUnitMainFilePath(declaration).fileName();
scopeFileName = getTranslationUnitMainFileName(declaration);
}
}
if (!scopeFileName.empty())
@@ -376,37 +370,42 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
}
}
const clang::SourceManager& sourceManager = declaration->getASTContext().getSourceManager();
const clang::PresumedLoc& presumedBegin = sourceManager.getPresumedLoc(declaration->getLocStart());
// LOG_ERROR("could not resolve name of decl at: " + declaration->getLocation().printToString(sourceManager));
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("symbol", presumedBegin), std::vector<std::string>());
return std::make_shared<CxxDeclName>(getNameForAnonymousSymbol("symbol", declaration), std::vector<std::string>());
}
FilePath CxxDeclNameResolver::getTranslationUnitMainFilePath(const clang::Decl* declaration)
std::string CxxDeclNameResolver::getTranslationUnitMainFileName(const clang::Decl* declaration)
{
const clang::SourceManager& sourceManager = declaration->getASTContext().getSourceManager();
clang::FileID fileId = sourceManager.getMainFileID();
if (fileId.isValid())
{
const clang::FileEntry* fileEntry = sourceManager.getFileEntryForID(fileId);
return FilePath(utility::getFileNameOfFileEntry(fileEntry));
return getCanonicalFilePathCache()->getCanonicalFilePath(fileEntry).fileName();
}
return FilePath();
return "";
}
FilePath CxxDeclNameResolver::getDeclarationFilePath(const clang::Decl* declaration)
std::string CxxDeclNameResolver::getDeclarationFileName(const clang::Decl* declaration)
{
const clang::SourceManager& sourceManager = declaration->getASTContext().getSourceManager();
const clang::FileEntry* fileEntry = sourceManager.getFileEntryForID(sourceManager.getFileID(declaration->getLocStart()));
if (fileEntry != nullptr && fileEntry->isValid())
{
return getCanonicalFilePathCache()->getCanonicalFilePath(fileEntry).fileName();
}
return getCanonicalFilePathCache()->getCanonicalFilePath(sourceManager.getPresumedLoc(declaration->getLocStart()).getFilename()).fileName();
}
std::string CxxDeclNameResolver::getNameForAnonymousSymbol(const std::string& symbolKindName, const clang::Decl* declaration)
{
const clang::SourceManager& sourceManager = declaration->getASTContext().getSourceManager();
const clang::PresumedLoc& presumedBegin = sourceManager.getPresumedLoc(declaration->getLocStart());
return FilePath(presumedBegin.getFilename());
}
std::string CxxDeclNameResolver::getNameForAnonymousSymbol(const std::string& symbolKindName, const clang::PresumedLoc& presumedBegin)
{
if (presumedBegin.isValid())
{
return "anonymous " + symbolKindName +
" (" + FilePath(presumedBegin.getFilename()).fileName() + "<" + std::to_string(presumedBegin.getLine()) + ":" + std::to_string(presumedBegin.getColumn()) + ">)";
" (" + getDeclarationFileName(declaration) + "<" + std::to_string(presumedBegin.getLine()) + ":" + std::to_string(presumedBegin.getColumn()) + ">)";
}
return "anonymous " + symbolKindName;
}
@@ -445,7 +444,7 @@ std::string CxxDeclNameResolver::getTemplateParameterString(const clang::NamedDe
std::string CxxDeclNameResolver::getTemplateParameterTypeString(const clang::NonTypeTemplateParmDecl* parameter)
{
CxxTypeNameResolver typeNameResolver(getIgnoredContextDecls());
CxxTypeNameResolver typeNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
if (clang::isa<clang::TemplateDecl>(m_currentDecl))
{
@@ -500,6 +499,6 @@ std::string CxxDeclNameResolver::getTemplateParameterTypeString(const clang::Tem
std::string CxxDeclNameResolver::getTemplateArgumentName(const clang::TemplateArgument& argument)
{
CxxTemplateArgumentNameResolver resolver(getIgnoredContextDecls());
CxxTemplateArgumentNameResolver resolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
return resolver.getTemplateArgumentName(argument);
}
src/lib_cxx/data/parser/cxx/name_resolver/CxxDeclNameResolver.h
+9 -5
View File
@@ -4,13 +4,17 @@
#include "data/parser/cxx/name/CxxDeclName.h"
#include "data/parser/cxx/name_resolver/CxxNameResolver.h"
class CanonicalFilePathCache;
class FilePath;
class CxxDeclNameResolver: public CxxNameResolver
{
public:
CxxDeclNameResolver();
CxxDeclNameResolver(std::vector<const clang::Decl*> ignoredContextDecls);
CxxDeclNameResolver(std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache);
CxxDeclNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
);
virtual ~CxxDeclNameResolver();
std::shared_ptr<CxxDeclName> getName(const clang::NamedDecl* declaration);
@@ -18,9 +22,9 @@ public:
private:
std::shared_ptr<CxxName> getContextName(const clang::DeclContext* declaration);
std::shared_ptr<CxxDeclName> getDeclName(const clang::NamedDecl* declaration);
FilePath getTranslationUnitMainFilePath(const clang::Decl* declaration);
FilePath getDeclarationFilePath(const clang::Decl* declaration);
std::string getNameForAnonymousSymbol(const std::string& symbolKindName, const clang::PresumedLoc& presumedBegin);
std::string getTranslationUnitMainFileName(const clang::Decl* declaration);
std::string getDeclarationFileName(const clang::Decl* declaration);
std::string getNameForAnonymousSymbol(const std::string& symbolKindName, const clang::Decl* declaration);
std::string getTemplateParameterString(const clang::NamedDecl* parameter);
std::string getTemplateParameterTypeString(const clang::NonTypeTemplateParmDecl* parameter);
std::string getTemplateParameterTypeString(const clang::TemplateTypeParmDecl* parameter);
src/lib_cxx/data/parser/cxx/name_resolver/CxxNameResolver.cpp
+11 -2
View File
@@ -1,7 +1,11 @@
#include "data/parser/cxx/name_resolver/CxxNameResolver.h"
CxxNameResolver::CxxNameResolver(std::vector<const clang::Decl*> ignoredContextDecls)
: m_ignoredContextDecls(ignoredContextDecls)
CxxNameResolver::CxxNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
)
: m_canonicalFilePathCache(canonicalFilePathCache)
, m_ignoredContextDecls(ignoredContextDecls)
{
}
@@ -30,6 +34,11 @@ bool CxxNameResolver::ignoresContext(const clang::DeclContext* declContext)
return false;
}
std::shared_ptr<CanonicalFilePathCache> CxxNameResolver::getCanonicalFilePathCache() const
{
return m_canonicalFilePathCache;
}
std::vector<const clang::Decl*> CxxNameResolver::getIgnoredContextDecls() const
{
return m_ignoredContextDecls;
src/lib_cxx/data/parser/cxx/name_resolver/CxxNameResolver.h
+9 -2
View File
@@ -3,21 +3,28 @@
#include <vector>
#include "clang/AST/Decl.h"
#include <clang/AST/Decl.h>
class CanonicalFilePathCache;
class CxxNameResolver
{
public:
CxxNameResolver(std::vector<const clang::Decl*> ignoredContextDecls);
CxxNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
);
virtual ~CxxNameResolver();
void ignoreContextDecl(const clang::Decl* decl);
bool ignoresContext(const clang::DeclContext* declContext);
protected:
std::shared_ptr<CanonicalFilePathCache> getCanonicalFilePathCache() const;
std::vector<const clang::Decl*> getIgnoredContextDecls() const;
private:
std::shared_ptr<CanonicalFilePathCache> m_canonicalFilePathCache;
std::vector<const clang::Decl*> m_ignoredContextDecls;
};
src/lib_cxx/data/parser/cxx/name_resolver/CxxSpecifierNameResolver.cpp
+11 -8
View File
@@ -7,13 +7,16 @@
#include "data/parser/cxx/name_resolver/CxxTypeNameResolver.h"
#include "data/parser/cxx/name_resolver/CxxDeclNameResolver.h"
CxxSpecifierNameResolver::CxxSpecifierNameResolver()
: CxxNameResolver(std::vector<const clang::Decl*>())
CxxSpecifierNameResolver::CxxSpecifierNameResolver(std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache)
: CxxNameResolver(canonicalFilePathCache, std::vector<const clang::Decl*>())
{
}
CxxSpecifierNameResolver::CxxSpecifierNameResolver(std::vector<const clang::Decl*> ignoredContextDecls)
: CxxNameResolver(ignoredContextDecls)
CxxSpecifierNameResolver::CxxSpecifierNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
)
: CxxNameResolver(canonicalFilePathCache, ignoredContextDecls)
{
}
@@ -48,20 +51,20 @@ std::shared_ptr<CxxName> CxxSpecifierNameResolver::getName(const clang::NestedNa
break;
case clang::NestedNameSpecifier::Namespace:
{
CxxDeclNameResolver declNameResolver(getIgnoredContextDecls());
CxxDeclNameResolver declNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
name = declNameResolver.getName(nestedNameSpecifier->getAsNamespace());
}
break;
case clang::NestedNameSpecifier::NamespaceAlias:
{
CxxDeclNameResolver declNameResolver(getIgnoredContextDecls());
CxxDeclNameResolver declNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
name = declNameResolver.getName(nestedNameSpecifier->getAsNamespaceAlias());
}
break;
case clang::NestedNameSpecifier::TypeSpec:
case clang::NestedNameSpecifier::TypeSpecWithTemplate:
{
CxxTypeNameResolver typeNameResolver(getIgnoredContextDecls());
CxxTypeNameResolver typeNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
name = CxxTypeName::makeUnsolvedIfNull(typeNameResolver.getName(nestedNameSpecifier->getAsType()));
}
break;
@@ -70,7 +73,7 @@ std::shared_ptr<CxxName> CxxSpecifierNameResolver::getName(const clang::NestedNa
break;
case clang::NestedNameSpecifier::Super:
{
CxxDeclNameResolver declNameResolver(getIgnoredContextDecls());
CxxDeclNameResolver declNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
name = declNameResolver.getName(nestedNameSpecifier->getAsRecordDecl());
}
break;
src/lib_cxx/data/parser/cxx/name_resolver/CxxSpecifierNameResolver.h
+5 -2
View File
@@ -10,8 +10,11 @@ class CxxName;
class CxxSpecifierNameResolver: public CxxNameResolver
{
public:
CxxSpecifierNameResolver();
CxxSpecifierNameResolver(std::vector<const clang::Decl*> ignoredContextDecls);
CxxSpecifierNameResolver(std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache);
CxxSpecifierNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
);
virtual ~CxxSpecifierNameResolver();
std::shared_ptr<CxxName> getName(const clang::NestedNameSpecifier* nestedNameSpecifier);
src/lib_cxx/data/parser/cxx/name_resolver/CxxTemplateArgumentNameResolver.cpp
+8 -5
View File
@@ -5,13 +5,16 @@
#include "data/parser/cxx/name_resolver/CxxTypeNameResolver.h"
CxxTemplateArgumentNameResolver::CxxTemplateArgumentNameResolver()
: CxxNameResolver(std::vector<const clang::Decl*>())
CxxTemplateArgumentNameResolver::CxxTemplateArgumentNameResolver(std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache)
: CxxNameResolver(canonicalFilePathCache, std::vector<const clang::Decl*>())
{
}
CxxTemplateArgumentNameResolver::CxxTemplateArgumentNameResolver(std::vector<const clang::Decl*> ignoredContextDecls)
: CxxNameResolver(ignoredContextDecls)
CxxTemplateArgumentNameResolver::CxxTemplateArgumentNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
)
: CxxNameResolver(canonicalFilePathCache, ignoredContextDecls)
{
}
@@ -28,7 +31,7 @@ std::string CxxTemplateArgumentNameResolver::getTemplateArgumentName(const clang
{
case clang::TemplateArgument::Type:
{
CxxTypeNameResolver typeNameResolver(getIgnoredContextDecls());
CxxTypeNameResolver typeNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
std::shared_ptr<CxxTypeName> typeName = CxxTypeName::makeUnsolvedIfNull(typeNameResolver.getName(argument.getAsType()));
return typeName->toString();
}
src/lib_cxx/data/parser/cxx/name_resolver/CxxTemplateArgumentNameResolver.h
+5 -2
View File
@@ -10,8 +10,11 @@ class DataType;
class CxxTemplateArgumentNameResolver: public CxxNameResolver
{
public:
CxxTemplateArgumentNameResolver();
CxxTemplateArgumentNameResolver(std::vector<const clang::Decl*> ignoredContextDecls);
CxxTemplateArgumentNameResolver(std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache);
CxxTemplateArgumentNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
);
virtual ~CxxTemplateArgumentNameResolver();
std::string getTemplateArgumentName(const clang::TemplateArgument& argument);
src/lib_cxx/data/parser/cxx/name_resolver/CxxTypeNameResolver.cpp
+16 -13
View File
@@ -9,13 +9,16 @@
#include "data/parser/cxx/name_resolver/CxxTemplateArgumentNameResolver.h"
#include "utility/logging/logging.h"
CxxTypeNameResolver::CxxTypeNameResolver()
: CxxNameResolver(std::vector<const clang::Decl*>())
CxxTypeNameResolver::CxxTypeNameResolver(std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache)
: CxxNameResolver(canonicalFilePathCache, std::vector<const clang::Decl*>())
{
}
CxxTypeNameResolver::CxxTypeNameResolver(std::vector<const clang::Decl*> ignoredContextDecls)
: CxxNameResolver(ignoredContextDecls)
CxxTypeNameResolver::CxxTypeNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
)
: CxxNameResolver(canonicalFilePathCache, ignoredContextDecls)
{
}
@@ -58,7 +61,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
}
case clang::Type::Typedef:
{
CxxDeclNameResolver declNameResolver(getIgnoredContextDecls());
CxxDeclNameResolver declNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
std::shared_ptr<CxxDeclName> declName = declNameResolver.getName(type->getAs<clang::TypedefType>()->getDecl());
if (declName)
{
@@ -118,7 +121,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
case clang::Type::Enum:
case clang::Type::Record:
{
CxxDeclNameResolver declNameResolver(getIgnoredContextDecls());
CxxDeclNameResolver declNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
std::shared_ptr<CxxDeclName> declName = declNameResolver.getName(type->getAs<clang::TagType>()->getDecl());
if (declName)
{
@@ -146,7 +149,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
const clang::TagType* tagType = type->getAs<clang::TagType>(); // remove this case when NameHierarchy is split into namepart and parameter part
if (tagType)
{
CxxDeclNameResolver declNameResolver(getIgnoredContextDecls());
CxxDeclNameResolver declNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
std::shared_ptr<CxxDeclName> declName = declNameResolver.getName(tagType->getDecl());
if (declName)
{
@@ -160,13 +163,13 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
else // specialization of a template template parameter (no concrete class) important, may help: has no underlying decl!
{
const clang::TemplateSpecializationType* templateSpecializationType = type->getAs<clang::TemplateSpecializationType>();
CxxDeclNameResolver declNameResolver(getIgnoredContextDecls());
CxxDeclNameResolver declNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
const std::shared_ptr<CxxDeclName> declName = declNameResolver.getName(templateSpecializationType->getTemplateName().getAsTemplateDecl());
if (declName)
{
std::vector<std::string> templateArguments;
CxxTemplateArgumentNameResolver resolver(getIgnoredContextDecls());
CxxTemplateArgumentNameResolver resolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
resolver.ignoreContextDecl(templateSpecializationType->getTemplateName().getAsTemplateDecl()->getTemplatedDecl());
for (size_t i = 0; i < templateSpecializationType->getNumArgs(); i++)
{
@@ -188,7 +191,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
}
case clang::Type::TemplateTypeParm:
{
CxxDeclNameResolver declNameResolver(getIgnoredContextDecls());
CxxDeclNameResolver declNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
std::shared_ptr<CxxDeclName> declName = declNameResolver.getName(clang::dyn_cast<clang::TemplateTypeParmType>(type)->getDecl());
if (declName)
{
@@ -209,7 +212,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
{
const clang::DependentNameType* dependentType = clang::dyn_cast<clang::DependentNameType>(type);
CxxSpecifierNameResolver specifierNameResolver(getIgnoredContextDecls());
CxxSpecifierNameResolver specifierNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
std::shared_ptr<CxxName> specifierName = specifierNameResolver.getName(dependentType->getQualifier());
typeName = std::make_shared<CxxTypeName>(
@@ -221,11 +224,11 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
{
const clang::DependentTemplateSpecializationType* dependentType = clang::dyn_cast<clang::DependentTemplateSpecializationType>(type);
CxxSpecifierNameResolver specifierNameResolver(getIgnoredContextDecls());
CxxSpecifierNameResolver specifierNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
std::shared_ptr<CxxName> specifierName = specifierNameResolver.getName(dependentType->getQualifier());
std::vector<std::string> templateArguments;
CxxTemplateArgumentNameResolver resolver(getIgnoredContextDecls());
CxxTemplateArgumentNameResolver resolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
for (size_t i = 0; i < dependentType->getNumArgs(); i++)
{
templateArguments.push_back(resolver.getTemplateArgumentName(dependentType->getArg(i)));
src/lib_cxx/data/parser/cxx/name_resolver/CxxTypeNameResolver.h
+5 -2
View File
@@ -7,8 +7,11 @@
class CxxTypeNameResolver: public CxxNameResolver
{
public:
CxxTypeNameResolver();
CxxTypeNameResolver(std::vector<const clang::Decl*> ignoredContextDecls);
CxxTypeNameResolver(std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache);
CxxTypeNameResolver(
std::shared_ptr<CanonicalFilePathCache> canonicalFilePathCache,
std::vector<const clang::Decl*> ignoredContextDecls
);
virtual ~CxxTypeNameResolver();
std::shared_ptr<CxxTypeName> getName(const clang::QualType& qualType);