Compiler Explorer

Source code

// utils.h

#include <utility>
#include <string_view>
#include <variant>

namespace mitzi {

template<class... Ts>
    struct type_list {
        template<class T>
        using push = type_list<Ts..., T>;

template<class T>
        using push_front = type_list<T, Ts...>;

template<template<class...> class T>
        using rename = T<Ts...>;

constexpr auto size() const { return sizeof...(Ts); }
    };

template<class T>
    struct type_wrapper {
        constexpr T get() const;
    };

template<auto V>
    struct value_wrapper {
        constexpr auto get() const { return V; }

template<class F>
        constexpr auto modify(F) const { return value_wrapper < F{}(V) > (); }

static constexpr auto value = V;
    };

template<class F, class... Ts>
    inline constexpr void for_each(F&& func, Ts&&... args) {
        (func(args), ...);
    }

template<class F, class... Ts>
    inline constexpr void for_each_type(F func, type_list<Ts...>) {
        for_each(func, type_wrapper<Ts>{}...);
    }

template<class T>
    struct scope_guard {
    private:
        T func;

public:
        scope_guard(T&& func) : func(std::forward<T>(func)) {}
        ~scope_guard() {
            func();
        }
    };

constexpr auto reverse(type_list<>) {
        return type_list<>{};
    }

template<class T, class... Ts>
    constexpr auto reverse(type_list<T, Ts...>) {
        using reversed = decltype(reverse(type_list<Ts...>{}))::template push<T>;
        return reversed{};
    }

template<int N>
    struct fixed_str {
        constexpr fixed_str(const char(&str)[N]) {
            for (int i = 0; i < N; ++i) {
                data[i] = str[i];
            }
        }

constexpr auto view() const {
            return std::string_view(data);
        }

char data[N] = {};
    };

template<class T, class... Ts>
    constexpr auto first(type_list<T, Ts...> list) {
        return type_wrapper<T>{};
    }

template<class T, class... Ts>
    constexpr auto pop_first(type_list<T, Ts...> list) {
        return type_list<Ts...>{};
    }

template<class T, class... Ts>
    constexpr auto push_first(type_wrapper<T>, type_list<Ts...>) {
        return type_list<T, Ts...>{};
    }

template<class... Ts, class... Us>
    constexpr auto filter(type_list<Ts...> list, auto predicate, type_list<Us...> acc = type_list{}) {
        if constexpr (sizeof...(Ts) == 0) {
            return acc;
        }
        else {
            constexpr auto rest = pop_first(list);
            constexpr auto head = first(list);
            if constexpr (!predicate(head)) {
                return filter(rest, predicate, acc);
            }
            else {
                return filter(rest, predicate, type_list<Us..., decltype(head.get())>{});
            }
        }
    }

template<auto... vs>
    struct value_list {
        template<auto V>
        using push_back = value_list<vs..., V>;

using types = type_list<decltype(vs)...>;

static constexpr auto size = sizeof...(vs);
    };

template<class T, class... Ts>
    constexpr auto contains(type_wrapper<T>, type_list<Ts...>) {
        return (... || std::is_same_v<T, Ts>);
    }

template <class... Ts, class... Us>
    constexpr auto unique(type_list<Ts...> input, type_list<Us...> output = type_list{}) {
        if constexpr (sizeof...(Ts) == 0) {
            return output;
        }
        else {
            auto type = first(input);
            auto rest = pop_first(input);
            if constexpr (contains(type, output)) {
                return unique(rest, output);
            }
            else {
                return unique(rest, push_first(type, output));
            }
        }
    }

template<class T, class... Ts>
    constexpr const T* try_get(const std::variant<Ts...>& v) {
        if constexpr (contains(type_wrapper<T>{}, type_list<Ts...>{})) {
            return std::get_if<T>(&v);
        }
        else {
            return nullptr;
        }
    }
}

// meta_state.h

#include <utility>

namespace mitzi {

template<int N, class T>
    struct state_t {
        static constexpr int n = N;
        using type = T;
    };

template<
        int N,
        auto tag
    >
    struct reader {
        friend auto inject_state_func(reader<N, tag>);
    };

template<
        int N,
        class T,
        auto tag
    >
    struct setter {
        static constexpr state_t<N, T> state{};
        
        friend auto inject_state_func(reader<N, tag>) {
            return state;
        }
    };

template<
        auto tag,
        auto eval,
        int N = 0
    >
    consteval auto get_last_state() {
        constexpr bool counted_past_n = requires(reader<N, tag> r) {
            inject_state_func(r);
        };

if constexpr (counted_past_n) {
            return get_last_state<tag, eval, N + 1>();
        }
        else {
            constexpr reader<N - 1, tag> r;
            return decltype(inject_state_func(r)){};
        }
    }

template<
        auto tag,
        auto eval = [] {},
        auto State = get_last_state<tag, eval>()
    >
    using get_state = typename std::remove_cvref_t<decltype(State)>;

template<
        class T,
        auto tag,
        auto eval
    >
    consteval auto set_state_impl() {
        using cur_state = decltype(get_last_state<tag, eval>());
        using next = setter<cur_state::n + 1, T, tag>;
        return next{}.state;
    }

struct none {};

template<class Init = none, auto tag = [] {} >
    class meta_state {
    public:
        template<
            typename T,
            auto eval = [] {}
        >
        using set = decltype(set_state_impl<T, tag, eval>());

template<auto eval = [] {} >
        using get = typename get_state<tag, eval>::type;

template<auto eval = [] {} >
        constexpr auto type() const->meta_state::get<eval>;
    private:
        static constexpr setter<0, Init, tag> init = {};
    };

}

// counter.h

namespace mitzi {
	template<auto Eval = [] {} >
	struct counter {
		using state = meta_state<value_wrapper<0>, Eval>;

template<
			auto eval = [] {},
			auto current = state::template get<eval>::value,
			class v = state::template set<value_wrapper<current + 1>, eval>
		>
		static constexpr auto next() {
			return current;
		}
	};
}

// validation_error.h

namespace mitzi {
	template<class T>
	struct validation_error {
		int record_index = -1;
		T message;
	};

template<auto V>
	inline constexpr auto assert_error_impl = false;

template<auto v>
	constexpr auto assert_error() {
		static_assert(assert_error_impl<v>);
	}
}

// recorder.h

#include <variant>
#include <array>

namespace mitzi {
	template<auto... vs>
	constexpr auto unpack_records(value_list<vs...>) {
		using types = type_list<decltype(vs)...>;
		using element_type = decltype(unique(types{}))::template rename<std::variant>;

return std::array<element_type, sizeof...(vs)>{ element_type(vs)... };
	}

template<auto error, auto Eval = [] {} >
	struct recorder {
		using state = meta_state<value_list<none{}>, Eval>;

template<
			auto value,
			auto eval = [] {}
		>
        static constexpr auto add(){
			using next = state::template get<eval>::template push_back<value>;
			using v = state::template set<next, eval>;

if constexpr (next::size - 1 == error.record_index) {
				assert_error<error.message>();
			}

return true;
        }

template<
			auto eval = [] {},
			class list = state::template get<eval>
		>
		static constexpr auto get() {
			return unpack_records(list{});
		}
	};

template<
		class record,
		auto eval = [] {},
		class list = record::state:: template get<eval>
	>
	using records_getter = decltype([] {
		return unpack_records(list{});
	});

template<class Record, int ID>
	struct record_and_id {
		static constexpr auto id = ID;
		using record = Record;
	};
}

// profile.h

#include <optional>
#include <span>

namespace mitzi {
	template<validation_error error, auto Eval = [] {}>
	struct profile_state {
		using counter = mitzi::counter<[]{}>;
		using record = mitzi::recorder<error, []{}>;
	};

template<class T, class U>
	using get_mixin = T::template mixin<U>;

constexpr auto default_validation_error = validation_error<none>{ -1, none{} };

template<class... Ts>
	struct profile {
		template<auto Eval, validation_error error_index = default_validation_error >
		struct validator : get_mixin<Ts, profile_state<error_index, Eval>>...{
			using state = profile_state<error_index, Eval>;
			using rules = type_list<Ts...>;

template<
			    auto eval = [] {},
				class list = state::record::state:: template get<eval>
			>
			static constexpr auto validate() {
                constexpr auto records = unpack_records(list{});
                
                return [records](this auto&& self, auto rules) {
					if constexpr (rules.size() == 0) {
						return std::optional<none>(std::nullopt);
					}
					else {
						constexpr auto error = decltype(first(rules).get())::validate(std::span(records));
						if constexpr (error) {
							return error;
						}
						else {
							return self(pop_first(rules));
						}
					}
				}(rules{});
			}

template<
				auto eval = [] {},
				class list = state::record::state:: template get<eval>
			>
			static constexpr auto get_records() {
				return unpack_records(list{});
			}
		};
	};

template<
		class Profile,
		class Fn,
		auto eval = [] {},
		class init = Profile::template validator<eval, default_validation_error > ,
		class init_records = records_getter<typename init::state::record>,
		class Ret = decltype(std::declval<Fn>()(init{}, init_records{})),
		class records = records_getter<typename init::state::record>
	>
	decltype(auto) run(Profile, Fn&& fn) {
		static constexpr auto optional_error = init::validate();
		static constexpr auto error = [] {
			if constexpr (optional_error) {
				return *optional_error;
			}
			else {
				return default_validation_error;
			}
		}();

using new_state = Profile::template validator < [] {}, error > ;
		return fn(new_state{}, records{});
		if constexpr (optional_error) {
			assert_error<optional_error->message>();
		}
	}
}

// control_flow_parser.h

#include <optional>
#include <variant>
#include <string_view>
#include <span>

namespace mitzi {
	enum class control_flow {
		start_scope,
		end_scope,
		if_,
		else_if,
		else_,
		for_loop,
		while_loop,
		return_,
		break_
	};

constexpr auto is_start_scope(control_flow flow) {
		return flow == control_flow::start_scope ||
			flow == control_flow::if_ ||
			flow == control_flow::else_ ||
			flow == control_flow::else_if ||
			flow == control_flow::for_loop ||
			flow == control_flow::while_loop;
	}

constexpr auto is_end_scope(control_flow flow) {
		return flow == control_flow::end_scope ||
			flow == control_flow::else_ ||
			flow == control_flow::else_if;
	}

struct control_flow_parser_rule {
		template<class state>
		struct mixin {
			static consteval control_flow parse_control(std::string_view str) {
				if (str == "{") return control_flow::start_scope;
				if (str == "}") return control_flow::end_scope;
				if (str.starts_with("if (") && str.ends_with(") {")) return control_flow::if_;
				if (str.starts_with("for (") && str.ends_with(") {")) return control_flow::for_loop;
				if (str.starts_with("for (") && str.ends_with(") {")) return control_flow::while_loop;
				if (str == "return;" || (str.starts_with("return ") && str.ends_with(";"))) return control_flow::return_;
				if (str == "break;") return control_flow::break_;

std::unreachable();
			}

template<
				fixed_str str,
				auto eval = [] {},
				auto control = parse_control(str.view()),
				auto v = state::record::template add<control, eval>()
			>
			using parse = decltype(control);
		};

template<class... Ts, std::size_t extent>
		static consteval std::optional<validation_error<none>> validate(std::span<const std::variant<Ts...>, extent> records) {
			return std::nullopt;
		}
	};
}

#define M_(...) sizeof(typename M::template parse<#__VA_ARGS__>); __VA_ARGS__

// ptr_rule.h

#include <vector>

namespace mitzi {
	enum class ptr_command {
		init,
		assign
	};

struct ptr_record {
		ptr_command command;
		int self_id;
		int other_id;
	};

template<
		class T,
		class record,
		int id
	>
	class ptr {
		template<
			class TT,
			class recordT,
			int idT
		> friend class ptr;
	public:
		ptr(T& value, record_and_id<record, id>) : data(&value) {}

template<
			auto eval = [] {},
			int other_id = -1,
			auto v = record::template add<ptr_record{ ptr_command::assign, id, other_id }, eval>()
		>
		ptr& assign(ptr<T, record, other_id> other) {
			this->data = other.data;
			return *this;
		}

private:
		T* data;
	};

struct error_lifetime_is_not_long_enough {};

struct ptr_rule {
		template<class state>
		struct mixin {
			template<
				auto eval = []{},
				auto id = state::counter::template next<eval>(),
                class T
			>
			static constexpr auto ptr(T&& value) {
                constexpr auto v = state::record::template add < ptr_record{ ptr_command::init, id, -1 } >();
                return mitzi::ptr(value, mitzi::record_and_id<typename state::record, id>{});
			}
		};

template<class... Ts, std::size_t extent>
		static constexpr std::optional<validation_error<error_lifetime_is_not_long_enough>> 
		validate(std::span<const std::variant<Ts...>, extent> records) {
			std::vector<int> ptrs;
			int depth = 1;
			
			for (int record_index = 0; record_index < records.size(); record_index++) {
				if (auto flow = try_get<control_flow>(records[record_index]); flow) {
					if (is_end_scope(*flow)) {
						depth--;
					}
					if (is_start_scope(*flow)) {
						depth++;
					}
				}
				else if (const ptr_record* rcd = try_get<ptr_record>(records[record_index]); rcd) {
					switch (rcd->command)
					{
					case ptr_command::init:
						if (ptrs.size() <= rcd->self_id) {
							ptrs.resize(rcd->self_id + 1, 0);
						}
						ptrs[rcd->self_id] = depth;
						break;
					case ptr_command::assign:
						if (ptrs[rcd->self_id] < ptrs[rcd->other_id]) {
							return validation_error(record_index, error_lifetime_is_not_long_enough{});
						}
						break;
					}
				}
			}

return std::nullopt;
		}
	};
}

// borrow_rule.h

#include <utility>

namespace mitzi {
	enum class borrow_command {
		ref,
		mut
	};

struct borrow_record {
		borrow_command command;
		int id;
	};

template<class T, class record, int N>
	class borrowable {
	public:
		template<class... Ts>
		borrowable(type_wrapper<T>, record_and_id<record, N>, Ts&&... args) :
			value(std::forward<Ts>(args)...)
		{}

template<
			auto eval = [] {},
			auto v = record::template add < borrow_record{ borrow_command::ref, N }, eval >()
		>
		const T& ref() const {
			return value;
		}

template<
			auto eval = [] {},
			auto v = record::template add < borrow_record{ borrow_command::mut, N }, eval >()
		>
		T& mut() {
			return value;
		}

private:
		T value;
	};

struct borrow_state {
		int ref_count = 0;
		int mut_count = 0;
	};

struct borrow_rule {
		template<class state>
		struct mixin {
			template<
				class T,
				auto eval = [] {},
				auto id = state::counter::template next<eval>(),
				class... Ts
			>
			static auto borrow(Ts&&... args) {
				return borrowable(
					type_wrapper<std::remove_cvref_t<T>>{},
					record_and_id<typename state::record, id>{},
					std::forward<Ts>(args)...);
			}

template<
				auto eval = [] {},
				auto id = state::counter::template next<eval>(),
				class T
			>
			static auto borrow(T&& arg) {
				return borrowable(
					type_wrapper<std::remove_cvref_t<T>>{},
					record_and_id<typename state::record, id>{},
					std::forward<T>(arg));
			}
		};

template<class... Ts, std::size_t extent>
		static consteval std::optional<validation_error<borrow_state>> validate(std::span<const std::variant<Ts...>, extent> records) {
			std::vector<std::vector<borrow_state>> borrows = { {} };

for (int record_index = 0; record_index < records.size(); record_index++) {
				if (auto flow = try_get<control_flow>(records[record_index]); flow) {
					if (is_end_scope(*flow)) {
						borrows.pop_back();
					}
					if (is_start_scope(*flow)) {
						auto copy = borrows.back();
						borrows.emplace_back(std::move(copy));
					}
				}
				else if (auto record = try_get<borrow_record>(records[record_index]); record) {
					if (borrows.back().size() <= record->id) {
						borrows.back().resize(record->id + 1);
					}
					auto& state = borrows.back()[record->id];
					switch (record->command)
					{
					case borrow_command::ref:
						state.ref_count++;
						break;
					case borrow_command::mut:
						state.mut_count++;
						break;
					default:
						std::unreachable();
					}

if (state.mut_count > 1 ||
						(state.mut_count == 1 && state.ref_count > 0)) {
						return validation_error(record_index, state);
					}
				}
			}

return std::nullopt;
		}
	};
}

// main.cpp

using namespace mitzi;

int main() {
	using safe_profile = profile<control_flow_parser_rule, ptr_rule, borrow_rule>;
	run(safe_profile{}, []<class M>(M, auto get_records) {
		auto vec = M::borrow(std::vector{42});

// uncommenting any of the line will produce an error
		M_({)
            auto outer = M::ptr(vec.ref()[0]);
			M_({)
                auto vec2 = M::borrow(std::vector{34});
				auto inner = M::ptr(vec2.ref()[0]);
				inner.assign(outer);
				//vec.mut().clear();
                //vec2.mut().clear();
				//outer.assign(inner);
			M_(})
		M_(})

auto& mut1 = vec.mut();
		//auto& mut2 = vec.mut();
		//auto& ref1 = vec.ref();
        
	});

return 0;
}