Clang - Получение полной информации о шаблоне SubstTemplateTypeParm - PullRequest
Новая
       22

Clang - Получение полной информации о шаблоне SubstTemplateTypeParm

8 голосов
/ 05 июля 2019

Я перебираю Clang AST, но у меня возникают проблемы с получением нужной информации при прохождении информации о типе объявления AST, которое содержит clang :: SubstTemplateTypeParmType.

Учитывая следующий минимальный входной код дляclang tooling 

#include <map>

template <typename K, typename V> using Map = std::map<K, V>;
using String = std::string;
using ParameterMap = Map<String, String>;

ParameterMap someFunc();

При рекурсии через тип ParameterMap clang говорит, что первый Map параметр arg, String, это clang::SubstTemplateTypeParmType.Если я попытаюсь выполнить дальнейшие действия, чтобы получить больше информации о String, либо отладив, либо получив тип замены (код ниже), базовый тип имеет значение Type::Record и std::basic_string.Это неожиданно для меня, так как я ожидаю, что базовый тип будет специализацией шаблона, что-то вроде basic_string<const char*, std::char_traits<const char*>, std::allocator<const char*>>.Поскольку узел является записью, я могу получить, что карта содержит std::basic_string, но не может получить информацию шаблона basic_string.Как я могу получить информацию о специализации шаблона basic_string в таком случае? 

case Type::SubstTemplateTypeParm:
{
    auto substTemplateType = qualType->getAs<SubstTemplateTypeParmType>();
    walkType(substTemplateType->getReplacementType());
    return;
}

Я понимаю требование опубликовать пример минимального исполняемого кода, который приведен ниже.Однако для этого требуется зависимость от набора инструментов, для которой нет предварительных сборок, поэтому подключать и запускать их не так просто.

Пути жестко запрограммированы, поэтому их необходимо обновлять в зависимости от локальной установки.Вот файл compile_commands, который также имеет 3 пути для обновления.Путь к компилятору и путь к файлу в конце дважды. 

[
{"directory":"F:/git/minRepro/","command":"\"C:/Program Files (x86)/compilers/clang.exe\" -Wall -isystem -g -std=c++14 -Wno-format -Wno-unneeded-internal-declaration -Werror F:/git/minRepro/exampleSource.cpp","file":"F:/git/minRepro/exampleSource.cpp"}
]

Код: 

#pragma comment(lib,"Version.lib")

#include <clang/Tooling/JSONCompilationDatabase.h>
#include <clang/Tooling/Tooling.h>
#include <clang/Frontend/FrontendAction.h>
#include <clang/Sema/SemaConsumer.h>
#include <clang/AST/Type.h>
#include <clang/AST/TemplateName.h>
#include <clang/AST/Decl.h>
#include <clang/AST/DeclTemplate.h>
#include <clang/Frontend/CompilerInstance.h>

#include <iostream>
#include <cstdlib>
#include <cassert>
#include <vector>
#include <string>

class AstWalker : public clang::SemaConsumer
{
public:
    AstWalker(clang::ASTContext& context)
        : m_context(context)
    {}

    virtual void HandleTranslationUnit(clang::ASTContext& context)
    {
        using namespace clang;

        for (auto declaration : context.getTranslationUnitDecl()->decls())
        {
            const auto&sm = m_context.getSourceManager();

            if (!declaration->getBeginLoc().isValid())
                continue;

            // Only walk declarations from our file.
            if (!sm.isInMainFile(sm.getSpellingLoc(declaration->getBeginLoc())))
                continue;

            // Find functions, and inspect their return type.
            auto nodeKind = declaration->getKind();
            if (nodeKind == Decl::Function)
            {
                auto funcDecl = cast<FunctionDecl>(declaration);

                // Check for and ignore built-in functions.
                if (funcDecl->getBuiltinID() != 0)
                    break;

                walkType(funcDecl->getReturnType());
                break;
            }
        }
    }

    void walkType(const clang::QualType& qualType)
    {
        using namespace clang;

        auto classType = qualType->getTypeClass();
        switch (classType)
        {
        case Type::Typedef:
        {
            auto typedefType = qualType->getAs<TypedefType>();
            walkType(typedefType->desugar());
            return;
        }
        case Type::TemplateSpecialization:
        {
            auto templateSpecialization = qualType->getAs<TemplateSpecializationType>();
            if (templateSpecialization->isTypeAlias())
            {
                walkType(templateSpecialization->getAliasedType());
                return;
            }

            std::string templateType = templateSpecialization->getTemplateName().getAsTemplateDecl()->getQualifiedNameAsString();
            std::cout << templateType << "<";

            auto numArgs = templateSpecialization->getNumArgs();
            for (unsigned int i = 0; i < numArgs; ++i)
            {
                if (i > 0)
                    std::cout << ", ";

                const clang::TemplateArgument& templateArg = templateSpecialization->getArg(i);
                if (templateArg.getKind() == clang::TemplateArgument::ArgKind::Type)
                {
                    walkType(templateArg.getAsType());
                }
            }

            std::cout << ">";
            return;
        }
        case Type::Record:
        {
            const auto record = qualType->getAs<RecordType>();
            std::string recordQualifiedName = record->getAsRecordDecl()->getQualifiedNameAsString();
            std::cout << recordQualifiedName;
            return;
        }
        case Type::Elaborated:
        {
            auto elaboratedType = qualType->getAs<ElaboratedType>();
            walkType(elaboratedType->desugar());
            return;
        }
        case Type::SubstTemplateTypeParm:
        {
            auto substTemplateType = qualType->getAs<SubstTemplateTypeParmType>();
            walkType(substTemplateType->desugar());
            //Also tried getReplacementType.
            //walkType(substTemplateType->getReplacementType());
            return;
        }
        }
    }

private:
    clang::ASTContext& m_context;
};

class ExampleAction : public clang::ASTFrontendAction
{
public:
    ExampleAction() {}

    virtual std::unique_ptr<clang::ASTConsumer> CreateASTConsumer(clang::CompilerInstance& compiler, llvm::StringRef inFile)
    {
        return std::unique_ptr<clang::ASTConsumer>(new AstWalker(compiler.getASTContext()));
    }
};

int main(int argc, char **argv)
{
    // Create the compilation database.
    std::string errorOut;
    std::unique_ptr<clang::tooling::JSONCompilationDatabase> compilationDatabase = clang::tooling::JSONCompilationDatabase::loadFromFile("F:/git/minRepro/compile_commands.json", errorOut, clang::tooling::JSONCommandLineSyntax::AutoDetect);

    if (compilationDatabase == nullptr || !errorOut.empty())
    {
        std::cout << "[Error] Failed to load compilation database. Error=" << errorOut.c_str() << std::endl;
        return false;
    }

    std::vector<std::string> headerFiles;
    headerFiles.push_back("F:/git/minRepro/exampleSource.cpp");
    clang::tooling::ClangTool tool(*compilationDatabase, llvm::ArrayRef<std::string>(headerFiles));

    auto toolResult = tool.run(clang::tooling::newFrontendActionFactory<ExampleAction>().get());
    if (toolResult == 1)
    {
        std::cout << "[Error] Error occurred.  Check log.  Aborting.\n";
        assert(false);
        return false;
    }
}

1 Ответ

1 голос
/ 09 июля 2019

В некоторых случаях информация шаблона вложена в ClassTemplateSpecializationDecl для данного RecordType. Вы можете прочитать это, бросив свой RecordDecl в ClassTemplateSpecializationDecl. 

const auto record = qualType->getAs<clang::RecordType>();
auto classTemplateSpecialization = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(record->getAsRecordDecl());
if (classTemplateSpecialization)
{
    const auto& args = classTemplateSpecialization->getTemplateArgs();
    for (unsigned int i = 0; i < args.size(); ++i)
    {
        const clang::TemplateArgument& templateArg = args[i];
        // Read arg info as needed.
    }   
}
else
{
    // Not a template specialization.
}
...