DeclarationTransformer

class DeclarationTransformer : public clang::ast_matchers::MatchFinder::MatchCallback
{
    private:

        clang::ASTContext &context;
        clang::Rewriter &rewriter;

    public:

        explicit DeclarationTransformer(clang::ASTContext &context, clang::Rewriter &rewriter);

        void doTransformation();
        virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &result) override;
};

DeclarationTransformer::DeclarationTransformer(clang::ASTContext &context, clang::Rewriter &rewriter)
        : context(context), rewriter(rewriter)
{}

void DeclarationTransformer::doTransformation()
{
    using namespace clang::ast_matchers;

    MatchFinder declgroupFinder;

    auto declStmtExpr = declStmt().bind("declstmt");
    declgroupFinder.addMatcher(declStmtExpr, this);

    declgroupFinder.matchAST(context);
}

void DeclarationTransformer::run(const clang::ast_matchers::MatchFinder::MatchResult &result)
{
    using namespace clang;
    using namespace clang_utilsA;

    if(const DeclStmt *declStmt = result.Nodes.getNodeAs<DeclStmt>("declstmt"))
    {
        if(declStmt->isSingleDecl() == false)
        {
            std::string transformed = "";

            for(auto it = declStmt->getDeclGroup().begin(); it != declStmt->getDeclGroup().end(); ++it)
            {
                if(const VarDecl *var = llvm::dyn_cast<VarDecl>(*it))
                {
                    VariableDeclaration variableDeclaration(var);

                    if(variableDeclaration.isPointer)
                    {
                        transformed += variableDeclaration.type + " *" + variableDeclaration.name;
                    }
                    else if(variableDeclaration.isPointerPointer)
                    {
                        transformed += variableDeclaration.type + " **" + variableDeclaration.name;
                    }
                    else if(variableDeclaration.isArray)
                    {
                        std::string typeWithName = variableDeclaration.fullType;

                        auto pos = typeWithName.rfind(" ");
                        typeWithName.insert(pos+1, variableDeclaration.name);

                        transformed += typeWithName;

                        // TODO: dont like the find-insert part. try to use arraySize.
                        // variableDeclaration.name + "[" + std::to_string(variableDeclaration.arraySize) + "]";
                    }
                    else
                    {
                        transformed += variableDeclaration.type + " " + variableDeclaration.name;
                    }

                    if(variableDeclaration.hasInit)
                    {
                        auto initStmt = rewriter.getRewrittenText(variableDeclaration.initValueRange);
                        transformed += " = " + initStmt;
                    }

                    transformed +=  ";\n    ";
                }
            }

            //llvm::outs() << transformed;
            rewriter.ReplaceText(declStmt->getSourceRange(), transformed);
        }
    }
}