Using Clang for static reflection

UCLASS()
class LEARN_UE5_API UEchoAnimInstance : public UAnimInstance
{
  GENERATED_BODY()
public:
  virtual void NativeInitializeAnimation() override;
  virtual void NativeUpdateAnimation(float DeltaSeconds) override;

  UPROPERTY(BlueprintReadOnly)
    AEcho* Character;

  UPROPERTY(BlueprintReadOnly, Category = "Movement")
  UCharacterMovementComponent* EchoMovement;

  UPROPERTY(BlueprintReadOnly, Category = "Movement")
  float GroundSpeed;

  UPROPERTY(BlueprintReadOnly, Category = "Movement")
  bool IsFalling;

  UPROPERTY(BlueprintReadOnly, Category = "Movement | CharacterState")
  ECharacterState CharacterState;
};

CGCLASS(LuaClass)
class Foo
{
    CGMEMBER(LuaInspect)
    std::unordered_map<std::string, std::shared_ptr<Bar>> Var;
public:
   CGMETHOD(LuaInspect)
    void Func(const std::shared_ptr<Bar>& bar);
};

#include "C:\Users\games\source\github\Code-Generation\Code_Generation\include\Linker.hpp"

void CreateBindings(sol::state& lua_state)
{
sol::usertype<Foo> Foo_table = lua_state.new_usertype<Foo>("Foo", sol::constructors<Foo()>{});
Foo_table["Func"] = &Foo::Func();
Foo_table["Var"] = &Foo::Var;
}

struct Physics
{
    glm::vec3 velocity{0.0f};
    glm::vec3 gravity{0.0f};
    glm::vec3 max_velocity{0.0f};
    bool has_gravity = true;
};

struct Physics
{
    glm::vec3 velocity{0.0f};
    glm::vec3 gravity{0.0f};
    glm::vec3 max_velocity{0.0f};
    bool has_gravity = true;
};

template<>
void ComponentEditorWidget<components::Physics>(entt::registry& registry, entt::entity entity)
{
    auto& physics = registry.get<components::Physics>(entity);

    //velocity
    ImGui::DragFloat3("Velocity", glm::value_ptr(physics.velocity), 0.1f);
    //gravity
    ImGui::DragFloat3("Gravity", glm::value_ptr(physics.gravity), 0.1f);
    //max velocity
    ImGui::DragFloat3("Max Velocity", glm::value_ptr(physics.max_velocity), 0.1f);
    //has gravity
    ImGui::Checkbox("Has Gravity", &physics.has_gravity);
};

void EngineClass::Initialize()
{
  ecs_->RegisterComponent<components::Physics>("Physics");
}

//header
class SimpleOptionParser : public clang::tooling::CompilationDatabase {
    std::vector<std::string> args;
    std::filesystem::path output_directory;
public:
    explicit SimpleOptionParser(const std::vector<std::string>& args);
    void SetOutputDirectory(const std::filesystem::path& output_directory);
    
    [[nodiscard]] std::vector<clang::tooling::CompileCommand> getCompileCommands(llvm::StringRef FilePath) const override;
};

SimpleOptionParser::SimpleOptionParser(const std::vector<std::string> &args) : args(args) {}

std::vector<clang::tooling::CompileCommand> SimpleOptionParser::getCompileCommands(llvm::StringRef FilePath) const {
    std::filesystem::path file{FilePath.str()};
    
    std::vector<std::string> newArgs{this->args};
    newArgs.emplace_back(FilePath.str());
    
    std::vector<clang::tooling::CompileCommand> commands{
            clang::tooling::CompileCommand(file.parent_path().string(), file.filename().string(), newArgs, output_directory.string() + "/" + FilePath.str())
    };
    return commands;
}

SimpleOptionParser optionParser{args, headers};
clang::tooling::ClangTool tool{optionParser, headers};

//ASTFrontenAction is our custom class
tool.run(clang::tooling::newFrontendActionFactory<ASTFrontendAction>().get());

//implement consumer
class ASTConsumer : public clang::ASTConsumer {
public:
    void HandleTranslationUnit(clang::ASTContext &context) override;
};

//implement frontend action
class ASTFrontendAction : public clang::SyntaxOnlyAction {
public:
    std::unique_ptr<clang::ASTConsumer>
    CreateASTConsumer(clang::CompilerInstance &compilerInstance, llvm::StringRef inFile) override;
};

std::unique_ptr<clang::ASTConsumer> ASTFrontendAction::CreateASTConsumer(clang::CompilerInstance &compilerInstance, llvm::StringRef inFile) {
    return std::make_unique<ASTConsumer>();
}

void ASTConsumer::HandleTranslationUnit(clang::ASTContext &context) {
    ASTFileParser parser{};

    parser.TraverseDecl(context.getTranslationUnitDecl());
}

#pragma once

#include <unordered_map>

class Linker
{
    std::unordered_map<std::string, std::shared_ptr<int>> objects;
public:
    void Link(const std::shared_ptr<int>& parser);
};

class ASTFileParser : public clang::RecursiveASTVisitor<ASTFileParser> {
}

struct Object {
    std::string name;
    std::string fullNamespace;
    std::filesystem::path path;
    std::vector<Property> properties{};
};

struct Variable : public Object {
    std::string type = "int";
};

struct Function : public Object {
    std::string returnType = "void";
    std::vector<Variable> parameters{};
    bool isConstruptor = false;
};

struct Class : public Object {
    std::vector<Variable> variables{};
    std::vector<Function> functions{};
};

struct Property {
    std::string name;
    std::string value;
};

class ASTFileParser : public clang::RecursiveASTVisitor<ASTFileParser> {
    friend class ASTConsumer;
    friend class FileGenerator;

    std::vector<Class> classes;
    std::vector<Function> functions;
    std::vector<Variable> variables;

    std::filesystem::path path;
public:
    explicit ASTFileParser(std::filesystem::path file) : path(std::move(file)) {};

    bool TraverseCXXRecordDecl(clang::CXXRecordDecl *decl);

    bool TraverseCXXConstructorDecl(clang::CXXConstructorDecl *decl);

    bool TraverseFieldDecl(clang::FieldDecl *decl);

    bool TraverseCXXMethodDecl(clang::CXXMethodDecl *decl);

    bool TraverseParmVarDecl(clang::ParmVarDecl *decl);

    bool TraverseVarDecl(clang::VarDecl *decl);

    bool TraverseFunctionDecl(clang::FunctionDecl *decl);
};

bool ASTFileParser::TraverseXXDecl(clang::XXDecl *decl) {
    {
        //We handle our custom visit here.
    }

    bool result = clang::RecursiveASTVisitor<ASTFileParser>::TraverseXXDecl(decl);

    {
        //we handle our walk up from here.
    }

    return result;
}

std::string ASTFileParser::GetTypeAsString(const clang::NamedDecl &type) {
    //get file location
    //get start and ending character
    clang::SourceRange range = type.getSourceRange();
    clang::SourceManager &sm = type.getASTContext().getSourceManager();

    llvm::StringRef source = clang::Lexer::getSourceText(clang::CharSourceRange::getCharRange(range), sm,
                                                         clang::LangOptions());

    std::string name = type.getNameAsString();
    //find string before the first space before name
    std::string typeString = source.str().substr(0, source.str().rfind(' ', source.str().find(name)));
    //remove "static" from the string
    std::regex staticRegex(R"(static\s+)");
    typeString = std::regex_replace(typeString, staticRegex, "");

    return typeString;
}

std::vector<Property> ASTFileParser::GetProperties(const clang::Decl &decl, std::string keyword) {
    auto line = GetLineAbove(decl);

    //test if the line starts with the keyword (ignoring whitespace)
    //if not return empty vector
    //remove leading whitespace
    line.erase(line.begin(), std::find_if(line.begin(), line.end(), [](int ch) { return !std::isspace(ch); }));
    if (line.find(keyword) != 0) {
        return {};
    }

    //find the first opening brace
    auto openBracePos = line.find('(');
    //find matching closing brace
    auto closeBracePos = line.find(')', openBracePos);

    //get the substring between the braces
    auto propertiesString = line.substr(openBracePos + 1, closeBracePos - openBracePos - 1);

    //split the string by commas
    std::vector<std::string> properties{};
    std::string::size_type pos = 0;
    std::string::size_type prev = 0;
    while ((pos = propertiesString.find(',', pos)) != std::string::npos) {
        properties.emplace_back(propertiesString.substr(prev, pos - prev));
        prev = ++pos;
    }

    //add the last property
    properties.emplace_back(propertiesString.substr(prev, pos - prev));

    //parse the properties.
    //properties should be in the format "name"="value".
    //value is optional, and if it is not present the value should be an empty string.
    std::vector<Property> result;
    for (const auto &property: properties) {
        //find the first equals sign
        auto equalsPos = property.find('=');

        //get the name
        auto name = property.substr(0, equalsPos);

        //get the value
        auto value = property.substr(equalsPos + 1);

        //remove whitespace from the name
        name.erase(std::remove_if(name.begin(), name.end(), [](char c) { return std::isspace(c); }), name.end());
        //remove whitespace from the value
        value.erase(std::remove_if(value.begin(), value.end(), [](char c) { return std::isspace(c); }), value.end());

        //add the property to the result
        result.emplace_back(Property{name, value});
    }

    return result;
}

bool ASTFileParser::TraverseCXXRecordDecl(clang::CXXRecordDecl *decl) {

    //test if decl is from current file, if not skip recursive traversal and continue to next decl
    if (DeclIsIncluded(*decl)) {
        return true;
    }

    auto properties = GetProperties(*decl, "CGCLASS");
    //if properties is empty skip recursive traversal and continue to next decl
    if (properties.empty()) {
        return true;
    }

    //handle setup here:
    {
        auto &Class = classes.emplace_back();
        classStack.push(classes.size() - 1);

        Class.fullNamespace = decl->getQualifiedNameAsString();
        Class.name = decl->getNameAsString();
        Class.path = path;
        Class.properties = properties;
    }

    bool result = clang::RecursiveASTVisitor<ASTFileParser>::TraverseCXXRecordDecl(decl);

    //handle teardown here:
    {
        classStack.pop();
    }

    return result;
}

struct FullFunction {
    //allow the user to specify a string which will be inserted before the function
    //this approach allows for easy creation of template functions as the prefix can be used to specify the template
    //afterward the user can use the function name to specify the template arguments
    std::string prefix;
    
    Function header;
    
    std::vector<std::string> body;
};

struct File  {
    std::unordered_set<std::filesystem::path> includes;
    
    std::vector<std::string> header;
    
    std::unordered_map<std::string, FullFunction> functions;
};

class FileGenerator {
public:
    static std::filesystem::path output_directory;
    static std::unordered_map<std::string, File> files;
    
    /// \brief The callback function that gets called whenever a new ASTFileParser gets parsed
    /// \param fileGenerator the FileGenerator that called this function
    /// \param parser the ASTFileParser that was parsed
    std::function<void(FileGenerator&, const ASTFileParser&)> ParseFile{};
    
    /// \brief The callback function that gets called whenever a new Class gets parsed
    /// \param fileGenerator the FileGenerator that called this function
    /// \param classes the Class that was parsed
    std::function<void(FileGenerator&, const Class& classes)> ParseClass{};
    
    /// \brief The callback function that gets called whenever a new Member variable gets parsed
    /// \param fileGenerator the FileGenerator that called this function
    /// \param variables the Member variable that was parsed
    std::function<void(FileGenerator&, const Variable& variables)> ParseMember{};
    
    /// \brief The callback function that gets called whenever a new Method gets parsed
    /// \param fileGenerator the FileGenerator that called this function
    /// \param functions the Method that was parsed
    std::function<void(FileGenerator&, const Function& functions)> ParseMethod{};
    
    /// \brief The callback function that gets called whenever a new variable gets parsed
    /// \param fileGenerator the FileGenerator that called this function
    /// \param variables the variable that was parsed
    /// \note this function is called for global variables, for member variables see ParseMember
    std::function<void(FileGenerator&, const Variable& variables)> ParseVariable{};
    
    /// \brief The callback function that gets called whenever a new function gets parsed
    /// \param fileGenerator the FileGenerator that called this function
    /// \param functions the function that was parsed
    /// \note this function is called for global functions, for member functions see ParseMethod
    std::function<void(FileGenerator&, const Function& functions)> ParseFunction{};
    
    /// \brief The parser function responsible for calling the callback functions
    /// \param parser the ASTFileParser to parse
    void Parse(const ASTFileParser& parser);
    
    /// \brief parses the provided ASTFileParser and returns the #include macro that will include the file
    /// \param parser the ASTFileParser to get the path from
    /// \return string in the form of #include "path"
    /// \note this function returns absolute paths so using this outside generated files will not work for others
    static std::string GetFileInclude(const ASTFileParser& parser);
    
    /// \brief returns the #include macro that will include the file based on the provided path
    /// \param path path to get the #include macro for
    /// \return string in the form of #include "path"
    static std::string GetFileInclude(const std::filesystem::path& path);
    
    /// \brief Get the property with the provided name from the provided properties
    /// \param properties vector of properties to search in
    /// \param name name of the property to search for
    /// \return pointer to the property if found, nullptr otherwise
    static const Property* GetProperty(const std::vector<Property>& properties, const std::string& name);
    
    /// \brief Write all files to disk
    /// \note function names are based on their keys in the files map, not their name in the variable
    /// \code{.cpp} files["file.cpp"].functions["Name1] = {"void", "Name2", {}} \endcode
    /// \note will have the name: Name1 in file.cpp
    static void WriteFiles();
};

void FileGenerator::WriteFiles() {
    for( const auto& file : files)
    {
        const auto output_file = output_directory / file.first;
        
        //create the directory if it doesn't exist
        std::filesystem::create_directories(output_file.parent_path());
        
        //open the file or create it if it doesn't exist
        std::ofstream output{output_file};
        //test if the file is open
        if (!output.is_open())
        {
            std::cerr << "Error: could not open " << output_file << std::endl;
            continue;
        }
        
        const auto& file_data = file.second;
        
        //write the includes
        for (const auto& include : file_data.includes)
        {
            output << GetFileInclude(include) << std::endl;
        }
        
        std::cout << std::endl;
        
        //write the header
        for (const auto& line : file_data.header)
        {
            output << line << std::endl;
        }
        
        output << std::endl;
        
        //write the functions
        for (const auto& function : file_data.functions)
        {
            //write the prefix
            if (!function.second.prefix.empty())
            {
                output << function.second.prefix;
            }
            
            //write the header
            output << function.second.header.returnType << " " << function.first << "(";
            for (size_t i = 0; i < function.second.header.parameters.size(); ++i)
            {
                output << function.second.header.parameters[i].type << " " << function.second.header.parameters[i].name;
                if (i != function.second.header.parameters.size() - 1)
                {
                    output << ", ";
                }
            }
            output << ")" << std::endl << "{" << std::endl;
            
            //write the body
            for (const auto& line : function.second.body)
            {
                output << line << std::endl;
            }
            
            output << "}" << std::endl;
            
            output << std::endl;
        }
    }
}

void FileGenerator::Parse(const ASTFileParser &parser) {
    if (ParseFile)
    {
        ParseFile(*this, parser);
    }
    
    for (const auto& function : parser.functions)
    {
        if (ParseFunction)
        {
            ParseFunction(*this, function);
        }
    }
    
    for (const auto& variable : parser.variables)
    {
        if (ParseVariable)
        {
            ParseVariable(*this, variable);
        }
    }
    
    for (const auto& class_ : parser.classes)
    {
        if (ParseClass)
        {
            ParseClass(*this, class_);
        }
        
        for (const auto& function : class_.functions)
        {
            if (ParseMethod)
            {
                ParseMethod(*this, function);
            }
        }
        
        for (const auto& variable : class_.variables)
        {
            if (ParseMember)
            {
                ParseMember(*this, variable);
            }
        }
    }
}

const Class *currentClass = nullptr;

void HandleClass(FileGenerator &fileGenerator, const Class &class_) {
    currentClass = &class_;

    auto &properties = class_.properties;
    if (FileGenerator::GetProperty(properties, "LuaClass") != nullptr) {
        FileGenerator::files["LuaBindings.cpp.gen"].includes.insert(class_.path);
        auto &function = FileGenerator::files["LuaBindings.cpp.gen"].functions["CreateBindings"];
        function.header.AddVariable({"sol::state&", "lua_state"});

        auto &body = function.body;
        std::string userTypeCreation =
                "sol::usertype<" + class_.fullNamespace + "> " + class_.name + "_table = lua_state.new_usertype<" +
                class_.fullNamespace + ">(\"" + class_.name + "\", sol::constructors<" + class_.fullNamespace +
                "()>{});";

        body.emplace_back(userTypeCreation);
    }
}

void HandleMember(FileGenerator &fileGenerator, const Variable &variable) {
    auto &properties = variable.properties;
    if (FileGenerator::GetProperty(properties, "LuaInspect") != nullptr) {
        FileGenerator::files["LuaBindings.cpp.gen"].includes.insert(variable.path);
        auto &function = FileGenerator::files["LuaBindings.cpp.gen"].functions["CreateBindings"];
        function.header.AddVariable({"sol::state&", "lua_state"});

        auto &body = function.body;
        std::string propertyCreation =
                currentClass->name + "_table[\"" + variable.name + "\"] = &" + variable.fullNamespace + ";";
        body.emplace_back(propertyCreation);
    }
}

void HandleMethod(FileGenerator &fileGenerator, const Function &function) {
    auto &properties = function.properties;
    if (FileGenerator::GetProperty(properties, "LuaInspect") != nullptr) {
        FileGenerator::files["LuaBindings.cpp.gen"].includes.insert(function.path);
        auto &fullFunction = FileGenerator::files["LuaBindings.cpp.gen"].functions["CreateBindings"];
        fullFunction.header.AddVariable({"sol::state&", "lua_state"});

        auto &body = fullFunction.body;
        std::string propertyCreation =
                currentClass->name + "_table[\"" + function.name + "\"] = &" + function.fullNamespace + "();";
        body.emplace_back(propertyCreation);
    }
}

CGCLASS(LuaClass)
class Foo
{
    CGMEMBER(LuaInspect)
    std::unordered_map<std::string, std::shared_ptr<Bar>> Var;
public:
   CGMETHOD(LuaInspect)
    void Func(const std::shared_ptr<Bar>& bar);
};

#include "C:\Users\games\source\github\Code-Generation\Code_Generation\include\Linker.hpp"

void CreateBindings(sol::state& lua_state)
{
sol::usertype<Foo> Foo_table = lua_state.new_usertype<Foo>("Foo", sol::constructors<Foo()>{});
Foo_table["Func"] = &Foo::Func();
Foo_table["Var"] = &Foo::Var;
}