基于 LibTooling 生成 C++ 的 Objective-C++ 包装接口想法初步验证

#ifndef annotate_h
#define annotate_h

#define GEN_ANNOTATE_CLASS __attribute__((annotate("native_gen_class")))
#define GEN_ANNOTATE_METHOD __attribute__((annotate("native_gen_method")))
#define GEN_ANNOTATE_INCLUDE __attribute__((annotate("native_gen_class_include")))
#endif /* annotate_h */

#ifndef kit_hpp
#define kit_hpp

#include <string>

#include "annotate.h"

using namespace std;

namespace TT {

struct GEN_ANNOTATE_CLASS GEN_ANNOTATE_INCLUDE Kit {
    int a = 0;
    GEN_ANNOTATE_METHOD bool vaild() const;
};
};  // namespace TT

class GEN_ANNOTATE_CLASS Kit2 {
    int a = 0;
    bool vaild() const;

    GEN_ANNOTATE_METHOD void test(string str);
    
    GEN_ANNOTATE_METHOD void test2(const char *str);
};

#endif /* kit_hpp */

clang++ -Xclang -ast-dump -fsyntax-only kit.cpp

mkdir LLVM
cd LLVM
wget https://github.com/llvm/llvm-project/archive/refs/tags/llvmorg-13.0.0-rc1.zip
unzip llvmorg-13.0.0-rc1.zip

//===- CppNativeGen.cpp ---------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Example clang plugin which simply prints the names of all the top-level decls
// in the input file.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/AST.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendActions.h"
#include "clang/Frontend/FrontendPluginRegistry.h"
#include "clang/Sema/Sema.h"
#include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Signals.h"
#include "llvm/Support/raw_ostream.h"

using namespace clang;

namespace {

static llvm::StringRef AnnotationClassName{"native_gen_class"};
static llvm::StringRef AnnotationMethodName{"native_gen_method"};

class CppNativeGenConsumer : public ASTConsumer {
    CompilerInstance &Instance;
    std::set<std::string> ParsedTemplates;

  public:
    CppNativeGenConsumer(CompilerInstance &Instance,
                         std::set<std::string> ParsedTemplates)
        : Instance(Instance)
        , ParsedTemplates(ParsedTemplates) {}

    bool HandleTopLevelDecl(DeclGroupRef DG) override {
        for (DeclGroupRef::iterator i = DG.begin(), e = DG.end(); i != e; ++i) {
            const Decl *D = *i;
            // TODO: NamespaceDecl CXXRecordDecl 需要考虑 嵌套
            if (const NamespaceDecl *NSD = dyn_cast<NamespaceDecl>(D)) {
                for (auto I : NSD->decls()) {
                    if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(I)) {
                        HandleCXXRecordDecl(RD);
                    }
                }
            } else if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
                HandleCXXRecordDecl(RD);
            }
        }

        return true;
    }

    void HandleCXXRecordDecl(const CXXRecordDecl *RD) {
        if (RD->hasAttr<AnnotateAttr>()) {
            AnnotateAttr *attr = RD->getAttr<AnnotateAttr>();
            if (attr->getAnnotation() == AnnotationClassName) {
                llvm::errs() << (RD->isStruct() ? "annotation struct: " : "annotation class: ") << RD->getNameAsString() << "\n";
                for (auto I : RD->decls()) {
                    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(I)) {
                        HandleCXXMethodDecl(MD);
                    }
                }
            }
        }
    }

    void HandleCXXMethodDecl(const CXXMethodDecl *MD) {
//        const CXXRecordDecl *RD = MD->getParent();
        if (MD->hasAttr<AnnotateAttr>()) {
            AnnotateAttr *attr = MD->getAttr<AnnotateAttr>();
            if (attr->getAnnotation() == AnnotationMethodName) {
                llvm::errs() << "\tmethod: " << MD->getNameAsString() << "\n";
                auto numParams = MD->getNumParams();
                for (unsigned int i = 0; i < numParams; i++) {
                    auto PD = MD->getParamDecl(i);
                    //                    PD->dump();

                    QualType type = PD->getType();

                    //                    if (true && !type.isNull()) {
                    //                      // If the type is sugared, also dump a (shallow) desugared type.
                    //                      SplitQualType D_split = type.getSplitDesugaredType();
                    //                      if (T_split != D_split)
                    //                          llvm::errs() << ":'" << QualType::getAsString(D_split, PrintPolicy) << "'";
                    //                    }

                    llvm::errs() << "\t\tparam: name -> " << PD->getNameAsString() << " type -> " << QualType::getAsString(type.split(), PrintingPolicy{{}}) << "\n";
                }
            }
        }
    }
};

class CppNativeGenAction : public PluginASTAction {
    std::set<std::string> ParsedTemplates;

  protected:
    std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                   llvm::StringRef) override {
        // 忽略警告
        CI.getDiagnostics().setClient(new IgnoringDiagConsumer());
        return std::make_unique<CppNativeGenConsumer>(CI, ParsedTemplates);
    }

    bool ParseArgs(const CompilerInstance &CI,
                   const std::vector<std::string> &args) override {

        return true;
    }
    void PrintHelp(llvm::raw_ostream &ros) {
        ros << "Help for CppNativeGen plugin goes here\n";
    }
};

}  // namespace

// static FrontendPluginRegistry::Add<CppNativeGenAction>
//     X("cpp-native-gen", "print function names");

using namespace clang;
using namespace tooling;
using namespace llvm;

static llvm::cl::OptionCategory OptsCategory("cpp-native-gen");
int main(int argc, const char **argv) {
    //    sys::PrintStackTraceOnErrorSignal(argv[0], false);
    //    PrettyStackTraceProgram X(argc, argv);

    auto ExpectedParser =
        CommonOptionsParser::create(argc, argv, OptsCategory);
    if (!ExpectedParser) {
        llvm::errs() << ExpectedParser.takeError();
        return 1;
    }
    CommonOptionsParser &OptionsParser = ExpectedParser.get();
    ClangTool Tool(OptionsParser.getCompilations(),
                   OptionsParser.getSourcePathList());

//    auto cmd = OptionsParser.getCompilations().getCompileCommands(OptionsParser.getSourcePathList().front()).front();

    /*
     /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/xxx
     
     /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/clang 是对上面路径的软连
    */
    Tool.appendArgumentsAdjuster(getInsertArgumentAdjuster(
        "-I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/clang/include",
        ArgumentInsertPosition::END));

    Tool.appendArgumentsAdjuster(getInsertArgumentAdjuster(
        "-I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1",
        ArgumentInsertPosition::END));

    Tool.appendArgumentsAdjuster(getInsertArgumentAdjuster(
        "-I/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include",
        ArgumentInsertPosition::END));

    return Tool.run(clang::tooling::newFrontendActionFactory<CppNativeGenAction>().get());
}