refactor.hpp

Go to the documentation of this file.

#pragma once

#include "arguments.hpp"
#include "common.hpp"

// #include "forces/forces.hpp"
// #include "halo_exchange/kernel_dependency_detector.hpp"
// #include "meta/meta.hpp"
// #include "variables/variables.hpp"

namespace ws2st {

    namespace refactor {

        class WashMatchCallback : public tooling::RefactoringCallback {
        private:
            WashCallbackFn callback_ptr;  // Pointer to function called when there's a match
        public:
            WashMatchCallback(WashCallbackFn callback_ptr) : callback_ptr(callback_ptr), RefactoringCallback() {}

            virtual void run(const MatchFinder::MatchResult& Result) { callback_ptr(Result, this->getReplacements()); }

            WashCallbackFn getCallback() { return callback_ptr; }

            friend std::ostream& operator<<(std::ostream& os, const WashMatchCallback& obj) {
                os << "WashMatchCallback[ WashCallbackFn(" << obj.callback_ptr << ")->"
                   << reinterpret_cast<const void*>(obj.callback_ptr) << "]";
                return os;
            }
        };

        class WashRefactoringAction {
        private:
            // Matchers can be one of many types -- currently just Statement/Declaration -- TODO: Add more as needed
            std::variant<StatementMatcher*, DeclarationMatcher*> matcher;
            WashCallbackFn callbackfn_ptr;  // Function pointer to use
        public:
            WashRefactoringAction(StatementMatcher* matcher_ptr, WashCallbackFn callback_ptr)
                : matcher(matcher_ptr), callbackfn_ptr(callback_ptr) {}

            WashRefactoringAction(DeclarationMatcher* matcher_ptr, WashCallbackFn callback_ptr)
                : matcher(matcher_ptr), callbackfn_ptr(callback_ptr) {}

            WashCallbackFn getCallbackFn() { return callbackfn_ptr; }

            std::variant<StatementMatcher*, DeclarationMatcher*> getMatcher() { return matcher; }
        };

        class WashComputationAction {
            WashComputeFn computefn_ptr;

        public:
            WashComputationAction(WashComputeFn computefn_ptr) : computefn_ptr(computefn_ptr) {}

            WashComputeFn getComputeFn() { return computefn_ptr; }
        };

        class RefactorPass {
        private:
            const std::vector<std::string>* applicable_subset;
            std::vector<WashRefactoringAction> ref_act;
            std::vector<WashComputationAction> com_act;

        public:
            RefactorPass(std::initializer_list<
                         std::variant<std::vector<std::string>*, WashRefactoringAction, WashComputationAction>>
                             actions)
                : applicable_subset(std::holds_alternative<std::vector<std::string>*>(*actions.begin())
                                        ? std::get<std::vector<std::string>*>(*actions.begin())
                                        : &AllFiles) {
                for (auto i = actions.begin() + 1; i != actions.end(); i++) {
                    if (std::holds_alternative<WashRefactoringAction>(*i)) {
                        ref_act.push_back(std::get<WashRefactoringAction>(*i));
                    } else if (std::holds_alternative<WashComputationAction>(*i)) {
                        com_act.push_back(std::get<WashComputationAction>(*i));
                    }
                }
            }

            const std::vector<WashRefactoringAction>& actions() const { return ref_act; }

            const std::vector<WashComputationAction>& computations() const { return com_act; }

            const std::vector<std::string>* files() const { return applicable_subset; }
        };

        class RefactoringToolConfiguration {
        private:
            std::vector<RefactorPass> refactoring_stages;

        public:
            RefactoringToolConfiguration(std::initializer_list<RefactorPass> passes)
                : refactoring_stages(passes.begin(), passes.end()) {}

            bool run(const WashOptions& opts) const;
        };

        void runRefactoring(const WashOptions& opts);

        namespace config {

            const RefactoringToolConfiguration& getConfigurationForImplementation(Implementations impl);

        }
    }

}