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;

    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 *varDecl = llvm::dyn_cast<VarDecl>(*it))
                {
                    const clang::ValueDecl *decl = varDecl;

                    const std::string name = decl->getNameAsString();
                    const std::string fullyType = decl->getType().getAsString();

                    std::string singleDeclaration = fullyType;

                    if(decl->getType()->isArrayType())          // in case of int *ptrArray[] this is preferred!
                    {
                        auto pos = singleDeclaration.find("[");
                        singleDeclaration.insert(pos, name);
                    }
                    else if(decl->getType()->isPointerType())
                    {
                        auto pos = singleDeclaration.rfind("*");
                        singleDeclaration.insert(pos+1, name);
                    }
                    else
                    {
                        singleDeclaration += " " + name;
                    }

                    // get initializer
                    if(varDecl->hasInit())
                    {
                        const Expr *expr = varDecl->getInit();

                        while(const ImplicitCastExpr *ice = llvm::dyn_cast<ImplicitCastExpr>(expr))
                            expr = ice->getSubExpr();

                        if(!llvm::isa<CXXConstructExpr>(expr))  // otherwise explicit ctor init-call
                        {
                            auto initValueRange = expr->getSourceRange();
                            auto initStmt = rewriter.getRewrittenText(initValueRange);

                            singleDeclaration += " = " + initStmt;
                        }

                    }

                    transformed += singleDeclaration + ";\n    ";

                }
            }

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