main.cpp2

import std.compat;
import cpp2b;
import dylib;
import nlohmann.json;
import xxh3;

fs: namespace == std::filesystem;
json: type == nlohmann::json;

log_error: <Args...: type>(fmt: std::format_string<Args...>, forward args...: Args) = {
	std::println("\033[0;31mERROR\033[0m: {}", std::format(fmt, args...));
}

log_error: <Args...: type>(srcloc: std::source_location, fmt: std::format_string<Args...>, forward args...: Args) = {
	std::println("\033[0;31mERROR\033[0m: {}:{}:{} {}", srcloc.file_name(), srcloc.line(), srcloc.column(), std::format(fmt, args...));
}

log_warning: <Args...: type>(fmt: std::format_string<Args...>, forward args...: Args) = {
	std::println("\033[0;33mWARNING\033[0m: {}", std::format(fmt, args...));
}

log_warning: <Args...: type>(srcloc: std::source_location, fmt: std::format_string<Args...>, forward args...: Args) = {
	std::println("\033[0;33mWARNING\033[0m: {}:{}:{} {}", srcloc.file_name(), srcloc.line(), srcloc.column(), std::format(fmt, args...));
}

log_info: <Args...: type>(fmt: std::format_string<Args...>, forward args...: Args) = {
	std::println("\033[0;36mINFO\033[0m: {}", std::format(fmt, args...));
}

log_success: <Args...: type>(fmt: std::format_string<Args...>, forward args...: Args) = {
	std::println("\033[0;32mSUCCESS\033[0m: {}", std::format(fmt, args...));
}

git_clone_url_matcher: @regex type = {
    regex := R"(^(?:git@|ssh://git@|https://|http://|git://)?([^:/]+)[:/]{1,2}([^/]+)/([^/]+?)(?:\.git)?$)";
}

ensure_dir: (dir: fs::path) = {
	status := fs::status(dir);

	if status.type() == fs::file_type::not_found {
		fs::create_directories(dir);
	}
}

expect_dir: (dir: fs::path) = {
	status := fs::status(dir);

	if status.type() != fs::file_type::directory {
		log_error("missing expected directory {}", dir.generic_string());
		log_error("make sure cpp2b is installed correctly");
		std::exit(1);
	}
}

expect_file: (f: fs::path) = {
	status := fs::status(f);
	type := status.type();

	if type != fs::file_type::regular {
		log_error("missing expected file {}", f.generic_string());
		log_error("make sure cpp2b is installed correctly");
		std::exit(1);
	}
}

hash_file: (p: fs::path) -> u64 = {
	f: std::ifstream = (p, std::ios::binary | std::ios::ate);
	size: size_t = unchecked_cast<size_t>(f.tellg());
	f.seekg(0, std::ios::beg);
	buffer: std::vector<char> = ();
	buffer.resize(size);
	f.read(buffer.data(), size);
	if f.fail() { return 0; }
	return XXH3_64bits(buffer.data(), buffer.size());
}

modules_dir: () = modules_dir(fs::current_path());
modules_dir: (base: fs::path) -> fs::path = {
	return base / ".cache" / "cpp2" / "mod";
}

binaries_dir: () = binaries_dir(fs::current_path());
binaries_dir: (base: fs::path) -> fs::path = {
	return base / ".cache" / "cpp2" / "bin";
}

find_closest_file: (filename) = find_closest_file(filename, fs::current_path());
find_closest_file: (filename, base: fs::path) -> std::optional<fs::path> = {
	if fs::exists(base / filename) {
		return base / filename;
	}

	if !base.has_parent_path() || base.parent_path() == base {
		return std::nullopt;
	}

	return find_closest_file(filename, base.parent_path());
}

expect: <T>(move opt: std::optional<T>, message) -> T = {
	if !opt {
		log_error("{}", message);
		std::exit(1);
	}

	return opt*;
}

GitHubRepo: type = {
	private repo_: fs::path;

	operator=: (out this, repo, branch) = {
		repo_ = repo;

		if !fs::exists(path() / ".git") {
			ensure_dir(path());
			git_("clone --depth=1 --branch=(branch)$ --filter=blob:none --sparse https://github.com/(repo_.generic_string())$ .");
		}
	}

	private git_: (this, args: std::string) = {
		cmd_str: std::string = "git -C (path().string())$ " + args;
		std::println("SUBCOMMAND: {}", cmd_str);
		if std::system(cmd_str.c_str()) != 0 {
			std::exit(1);
		}
	}

	path: (this) -> fs::path = {
		return fs::current_path() / ".cache" / "cpp2" / "repos" / repo_;
	}

	add: (this, subpath: std::string) = {
		if !fs::exists(path() / subpath) {
			git_("sparse-checkout add (subpath)$");
		}
	}
}

USAGE: std::string_view = R"docopt(
cpp2b - CLI for CPP2

Usage:
	cpp2b build
	cpp2b clean
	cpp2b run
)docopt";

module_source_extension: (compiler: cpp2b::compiler_type) -> std::string_view = {
	if compiler == cpp2b::compiler_type::msvc  { return ".ixx"; }
	if compiler == cpp2b::compiler_type::clang { return ".cppm"; }
	if compiler == cpp2b::compiler_type::gcc   { return ".cxx"; }
	std::exit(1);
}

bmi_extension: (compiler: cpp2b::compiler_type) -> std::string_view = {
	if compiler == cpp2b::compiler_type::msvc  { return ".ifc"; }
	if compiler == cpp2b::compiler_type::clang { return ".pcm"; }
	if compiler == cpp2b::compiler_type::gcc   { return ".pcm"; } // TODO: Is this right?
	std::exit(1);
}

generate_cpp2b_module: () = {
	using std::string_literals::_;

	cpp2b_module_template_path: fs::path = share_dir() / "cpp2b.cppm.tpl"s;
	cpp2b_module_template_stream: std::ifstream = (cpp2b_module_template_path);

	if !cpp2b_module_template_stream {
		log_error("failed to open {}", cpp2b_module_template_path.generic_string());
		std::exit(1);
	}

	cpp2b_module_source_path: fs::path = ".cache/cpp2/source/_build/cpp2b(module_source_extension(cpp2b::compiler()))$";
	cpp2b_module_source_stream: std::ofstream = (cpp2b_module_source_path);

	if !cpp2b_module_source_stream {
		log_error("failed to open {}", cpp2b_module_source_path.generic_string());
		std::exit(1);
	}

	vars: std::unordered_map<std::string, std::string> = (
		std::pair("@CPP2B_PROJECT_ROOT@", fs::current_path().string())
	);
	
	line: std::string = "";
	while std::getline(cpp2b_module_template_stream, line) {
		for vars do (entry) {
			var_name := entry.first;
			var_value := entry.second;
			pos := line.find(var_name);

			if pos != std::string::npos {
				line.replace(pos, var_name.size(), var_value);
			}
		}
		cpp2b_module_source_stream << line << "\n";
	}

	cpp2b_module_template_stream.close();
	cpp2b_module_source_stream.close();

	impl: cpp2b_detail_cpp1_module_impl = ();
	impl.source_path = cpp2b_module_source_path;
	build_cpp1_module(impl, "cpp2b", :std::vector=("std", "std.compat"));
}

generate_cpp2b_build_module: () = {
	using std::string_literals::_;

	cpp2b_module_template_path: fs::path = share_dir() / "cpp2b.build.cppm.tpl"s;
	cpp2b_module_source_path: fs::path = ".cache/cpp2/source/_build/cpp2b.build(module_source_extension(cpp2b::compiler()))$";

	cpp2b_module_source_stream: std::ofstream = (cpp2b_module_source_path);
	cpp2b_module_template_stream: std::ifstream = (cpp2b_module_template_path);

	vars: std::unordered_map<std::string, std::string> = (
		std::pair("@CPP2B_PROJECT_ROOT@", fs::current_path().string())
	);
	
	line: std::string = "";
	assert(cpp2b_module_template_stream);
	while std::getline(cpp2b_module_template_stream, line) {
		for vars do (entry) {
			var_name := entry.first;
			var_value := entry.second;
			pos := line.find(var_name);

			if pos != std::string::npos {
				line.replace(pos, var_name.size(), var_value);
			}
		}
		cpp2b_module_source_stream << line << "\n";
	}

	cpp2b_module_template_stream.close();
	cpp2b_module_source_stream.close();


	impl: cpp2b_detail_cpp1_module_impl = ();
	impl.source_path = cpp2b_module_source_path;
	build_cpp1_module(impl, "cpp2b.build", :std::vector=("std", "std.compat"));
}

get_vs_tools_dir: () -> fs::path = {
	return cpp2b::env::get_var("VCToolsInstallDir")
		.expect("missing 'VCToolsInstallDir' environment variable")
		.fs::canonical();
}

get_llvm_root: () -> fs::path = {
	return "/usr/lib/llvm-19";
}

get_system_modules_dir: (compiler: cpp2b::compiler_type) -> fs::path = {
	if compiler == cpp2b::compiler_type::msvc  { return get_vs_tools_dir() / "modules"; }
	if compiler == cpp2b::compiler_type::clang { return get_llvm_root() / "share" / "libc++" / "v1"; }
	log_error("cannot find system cpp20 modules directory");
	std::exit(1);
}

ensure_system_module: (name: std::string) = {
	ensure_system_module(name, :std::vector<std::string> = ());
}

ensure_system_module: (name: std::string, deps) = {
	d := modules_dir();
	bmi := d / std::format("{}{}", name, bmi_extension(cpp2b::compiler()));
	system_modules_dir := get_system_modules_dir(cpp2b::compiler());

	if !fs::exists(bmi) {
		impl: cpp2b_detail_cpp1_module_impl = ();
		impl.source_path = system_modules_dir / std::format("{}{}", name, module_source_extension(cpp2b::compiler()));
		build_cpp1_module(impl, name, deps);
	}
}

ensure_std_modules: () = {
	ensure_system_module("std");
	ensure_system_module("std.compat", :std::vector=("std"));
}


cl_build_cpp1_module_cmd: (impl: cpp2b_detail_cpp1_module_impl, name: std::string, module_deps, bmi_path: fs::path) -> std::string = {
	d := fs::absolute(modules_dir());
	cmd_str: std::string = "cl /nologo /std:c++latest /W4 /MDd /EHsc /c /interface /TP";

	for impl.system_include_directories do (dir: fs::path) {
		cmd_str += " /I\"(fs::absolute(dir).string())$\"";
	}

	for impl.include_directories do (dir: fs::path) {
		cmd_str += " /I\"(fs::absolute(dir).string())$\"";
	}

	for module_deps do (dep: std::string) {
		dep_bmi := d / ("(dep)$.ifc");
		cmd_str += " /reference \"(dep_bmi.string())$\"";
	}
	cmd_str += " \"(fs::absolute(impl.source_path).string())$\"";
	cmd_str += " /ifcOutput \"(bmi_path.string())$\"";
	return cmd_str;
}


unix_build_cpp1_module_cmd: (impl: cpp2b_detail_cpp1_module_impl, compiler_cmd: std::string, name: std::string, module_deps, bmi_path: fs::path) -> std::string = {
	d := fs::absolute(modules_dir());
	sys_inc_dir := get_llvm_root() / "include" / "c++" / "v1";
	cmd_str: std::string = std::format("{} -stdlib=libc++ -std=c++23 -fexperimental-library", compiler_cmd);
	cmd_str += std::format(" -isystem \"{}\"", fs::absolute(sys_inc_dir).string());

	for impl.system_include_directories do (dir: fs::path) {
		cmd_str += std::format(" -isystem \"{}\"", fs::absolute(dir).string());
	}

	for impl.include_directories do (dir: fs::path) {
		cmd_str += std::format(" -I\"{}\"", fs::absolute(dir).string());
	}

	cmd_str += std::format(" -fprebuilt-module-path=\"{}\"", fs::absolute(d).string());
	cmd_str += " \"(fs::absolute(impl.source_path).string())$\"";
	cmd_str += std::format(" --precompile -o {}/{}.pcm", d.string(), name);
	return cmd_str;
}

build_cpp1_module: (impl: cpp2b_detail_cpp1_module_impl, name: std::string, module_deps) = {
	compiler :== cpp2b::compiler();
	d := fs::absolute(modules_dir());
	bmi := d / std::format("{}{}", name, bmi_extension(compiler));
	log_path := fs::path(".cache") / "cpp2" / "log" / "build" / ("(name)$.log");

	fs::remove(bmi);
	ensure_dir(log_path.parent_path());

	cmd_str: std::string = "";
	     if compiler == cpp2b::compiler_type::msvc { cmd_str = cl_build_cpp1_module_cmd(impl, name, module_deps, bmi); }
	else if compiler == cpp2b::compiler_type::clang { cmd_str = unix_build_cpp1_module_cmd(impl, "clang-19", name, module_deps, bmi); }
	else if compiler == cpp2b::compiler_type::gcc { cmd_str = unix_build_cpp1_module_cmd(impl, "gcc", name, module_deps, bmi); }
	else { log_error("unsupported compiler"); std::exit(1); }

	cmd_str += cmd_log_output(fs::absolute(log_path));

	cwd := fs::current_path();
	fs::current_path(d);
	duration: std::chrono::milliseconds;
	exit_code := measure(:()=std::system(cmd_str$.c_str()), out duration);
	fs::current_path(cwd);

	log_info("compile module {} ({}ms)", name, duration.count());

	if exit_code != 0 {
		log_error("failed to compile module {}", name);
		log_error("{}", cmd_str);
		print_log_file(log_path);
		std::exit(1);
	}
}

has_env: (var_name: *const char) -> bool = {
	return cpp2b::env::get_var(var_name).has_value();
}

has_msvc_env_vars: () -> bool = {
	return has_env("INCLUDE") && has_env("LIB") && has_env("VCToolsVersion");
}

home_dir: () -> fs::path = {
	if constexpr cpp2b::target_platform() == cpp2b::platform::windows {
		return cpp2b::env::get_var("USERPROFILE").expect("USERPROFILE does not exist");
	} else {
		return cpp2b::env::get_var("HOME").expect("HOME does not exist");
	}
}

share_dir_: fs::path = ();
share_dir: () -> fs::path = {
	if share_dir_.empty() {
		log_error("internal error - share dir was not setup");
		std::exit(1);
	}

	return share_dir_;
}

setup_share_dir: () = {
	exec_path := cpp2b::env::executable_path();
	if exec_path.empty() {
		log_error("failed to get executable path");
		std::exit(1);
	}
	
	if !exec_path.has_parent_path() {
		log_error("invalid cpp2b install location");
		std::exit(1);
	}

	share_dir_ = fs::weakly_canonical(exec_path.parent_path() / ".." / "share" / "cpp2b");

	if fs::exists(share_dir_) {
		return;
	}
	
	// we are only checking for CPP2B_PROJECT_ROOT so we can run cpp2b with cpp2b
	running_project_root := cpp2b::env::get_var("CPP2B_PROJECT_ROOT");
	if !running_project_root {
		log_error("failed to find {}", share_dir_.generic_string());
		log_error("please make sure cpp2b is installed correctly");
		std::exit(1);
	}
	
	log_warning("using CPP2B_PROJECT_ROOT to find share directory");
	share_dir_ = fs::absolute(fs::path(running_project_root.value())) / "share" / "cpp2b";
	log_warning("using share directory {}", share_dir_.generic_string());
	share_dir_ = share_dir_.generic_string();
}

run_with_msvc_env_vars: (args) -> int = {
	using std::views::drop;
	using std::string_literals::_;

	p: fs::path = fs::absolute(share_dir() / "run_with_msvc_env.cmd"s);

	cmd_str: std::string = p.string() + " " + std::string(args[0]);
	for args | drop(1) do (arg) {
		cmd_str += " (arg)$";
	}

	return std::system(cmd_str.c_str());
}

run_with_args: (args) -> int = {
	cmd_str: std::string = "";
	for args do (arg) {
		cmd_str += " (arg)$";
	}

	return std::system(cmd_str.c_str());
}

main: (args) -> int = {
	using std::views::drop;
	using std::string_literals::_;

	setup_share_dir();

	argz: std::vector<std::string_view> = ();

	// NOTE: this doesn't work on clang 18 with licxx for some reason
	// argz: std::vector<std::string_view> = (args.begin(), args.end());
	argz.reserve(args.size());
	for args do(arg: std::string_view) {
		argz.emplace_back(arg);
	}

	if fs::exists(".cache/cpp2/.env") {
		log_info("loading cached environment variables");
		env_file: std::ifstream = (".cache/cpp2/.env");
		line: std::string = "";
		while env_file && std::getline(env_file, line) {
			eq_index := line.find("=");
			if eq_index == std::string::npos { continue; }
			var_name: std::string_view = (line.data(), eq_index);
			var_value: std::string_view = (line.data() + eq_index + 1, line.size() - eq_index);
			cpp2b::env::set_var(var_name, var_value);
		}
	}

	if constexpr cpp2b::compiler() == cpp2b::compiler_type::msvc {
		if !has_msvc_env_vars() {
			return run_with_msvc_env_vars(argz);
		} else {
			vc_tools_version := cpp2b::env::get_var("VCToolsVersion").expect("msvc env internal error");

			after_major_index := vc_tools_version.find(".");
			after_minor_index := vc_tools_version.find(".", after_major_index + 1);

			major_version := vc_tools_version.substr(0, after_major_index).std::stoi();
			minor_version := vc_tools_version.substr(after_major_index + 1, after_minor_index - after_major_index - 1).std::stoi();

			if major_version == 14 && minor_version >= 44 {
				log_error("vs tools version {} is unsupported", vc_tools_version);
				log_error("please install vs tools 14.42 or 14.43");
				std::exit(1);
			}

			log_info("using vs tools {}", vc_tools_version);

			if !fs::exists(".cache/cpp2/.env") {
				log_info("saving environment variables");
				env_file: std::ofstream = (".cache/cpp2/.env");
				for cpp2b::env::vars() do(entry) {
					env_file << entry.name << "=" << entry.value << "\n";
				}
			}
		}
	} else {
		sys_lib_dir := get_llvm_root() / "lib";
		ld_library_path := cpp2b::env::get_var("LD_LIBRARY_PATH");
		if !ld_library_path || !ld_library_path*.contains(sys_lib_dir.string()) {
			log_info("setting LD_LIBRARY_PATH to '{}'", sys_lib_dir.string());
			cpp2b::env::set_var("LD_LIBRARY_PATH", sys_lib_dir.string());
			return run_with_args(argz);
		}
	}
	
	ensure_dir(".cache/cpp2/mod");
	ensure_dir(".cache/cpp2/bin");
	ensure_dir(".cache/cpp2/log");
	ensure_dir(".cache/cpp2/repos");
	ensure_dir(".cache/cpp2/tools");
	ensure_dir(".cache/cpp2/source/_build");

	i:=1U; while argz.size() > i next i++ {
		arg := argz[i];

		if !arg.starts_with("-") {
			remaining_args := argz | drop(i + 1);
			return inspect arg -> int {
				is "build" = subcommands::build(remaining_args);
				is "clean" = subcommands::clean(remaining_args);
				is "init"  = subcommands::init(remaining_args);
				is "run"   = subcommands::run(remaining_args);
				is _       = subcommands::unknown(arg);
			};
		}

		if arg == "--help" || arg == "-h" {
			std::print("{}", USAGE);
			return 0;
		}

		log_error("unknown flag '{}'", arg);
		return 1;
	}

	log_error("requires subcommand");
	std::print("{}", USAGE);

	return 1;
}

executable_extension: () -> std::string_view =  {
	if constexpr cpp2b::target_platform() == cpp2b::platform::windows {
		return ".exe";
	} else {
		return "";
	}
}

shared_library_extension: () -> std::string_view =  {
	if constexpr cpp2b::target_platform() == cpp2b::platform::windows {
		return ".dll";
	} else if constexpr(cpp2b::target_platform() == cpp2b::platform::macos) {
		return ".dylib";
	} else {
		return ".so";
	}
}

cmd_log_output: (log_file_path: fs::path) -> std::string = {
	return " > (log_file_path.string())$ 2>&1";
}

transpile_cpp2_result: @struct type = {
	src: fs::path = ();
	cpp1_output: fs::path = ();
	output_log: fs::path = ();
	cppfront_exit_code: int = ();
	duration: std::chrono::milliseconds = ();
}

measure: (move fn, out duration: std::chrono::milliseconds) -> _ = {
	before := std::chrono::high_resolution_clock::now();
	result := fn();
	after := std::chrono::high_resolution_clock::now();
	duration = duration_cast<std::chrono::milliseconds>(after - before);
	return result;
}

transpile_cpp2: (src: fs::path, out_dir: fs::path) -> transpile_cpp2_result = {
	result: transpile_cpp2_result = ();
	result.src = fs::path(src);
	result.cpp1_output = out_dir / fs::path(src).replace_extension(".cpp");
	result.output_log = fs::path(".cache") / "cpp2" / "log" / "transpile" / fs::path(src).replace_extension(".log");
	ensure_dir(result.output_log.parent_path());

	cppfront := fs::absolute(".cache/cpp2/tools/cppfront(executable_extension())$");
	cmd_str: std::string = "(cppfront.string())$ (src.string())$ -o (result.cpp1_output.string())$ -pure -import-std -l -format-colon-errors (cmd_log_output(result.output_log))$";
	ensure_dir(result.cpp1_output.parent_path());

	result.cppfront_exit_code = measure(
		:()=std::system(cmd_str$.c_str()),
		out result.duration,
	);

	return result;
}

unix_compile_cppfront: (cc: std::string_view, cppfront_source: fs::path, out_cppfront_binary: fs::path, log_path: fs::path) -> int = {
	cwd := fs::current_path();
	cmd_str: std::string = "(cc)$ -lstdc++ -lc -lm -std=c++20 cppfront.cpp -o (out_cppfront_binary.string())$ (cmd_log_output(fs::absolute(log_path)))$";
	fs::current_path(cppfront_source / "source");
	exit_code := std::system(cmd_str.c_str());
	fs::current_path(cwd);
	return exit_code;
}

cl_compile_cppfront: (cppfront_source: fs::path, out_cppfront_binary: fs::path, log_path: fs::path) -> int = {
	cwd := fs::current_path();
	cmd_str: std::string = "cl.exe /nologo /std:c++latest /EHsc cppfront.cpp (cmd_log_output(fs::absolute(log_path)))$";
	fs::current_path(cppfront_source / "source");
	exit_code := std::system(cmd_str.c_str());
	if exit_code == 0 {
		fs::copy_file("cppfront.exe", out_cppfront_binary, fs::copy_options::overwrite_existing);
	}
	fs::current_path(cwd);
	return exit_code;
}

ensure_cppfront: (cppfront_source: fs::path) -> int = {
	cppfront: fs::path = ".cache/cpp2/tools/cppfront(executable_extension())$";
	if !fs::exists(cppfront) {
		log_info("compiling cppfront...");

		cppfront_compile_log_path: fs::path = ".cache/cpp2/log/cppfront.log";

		if cpp2b::compiler() == cpp2b::compiler_type::clang {
			return unix_compile_cppfront("clang-19", fs::absolute(cppfront_source), fs::absolute(cppfront), cppfront_compile_log_path);
		}

		if cpp2b::compiler() == cpp2b::compiler_type::gcc {
			return unix_compile_cppfront("gcc", fs::absolute(cppfront_source), fs::absolute(cppfront), cppfront_compile_log_path);
		}

		if cpp2b::compiler() == cpp2b::compiler_type::msvc {
			return cl_compile_cppfront(fs::absolute(cppfront_source), fs::absolute(cppfront), cppfront_compile_log_path);
		}

		log_error("unknown compiler");
		std::exit(1);
	}

	return 0;
}

warn_if_error: (context, p: fs::path, ec: std::error_code) -> void = {
	if ec {
		log_warning("({}) {} - {}", context, p.generic_string(), ec.message());
	}
}

find_git_root: (copy dir: fs::path) -> std::optional<fs::path> = {
	while !dir.empty() {
		if fs::exists(dir / ".git") { return dir; }
		parent_dir := dir.parent_path();
		if parent_dir == dir { break; }
		dir = parent_dir;
	}

	return std::nullopt;
}

find_root_dir: (copy dir: fs::path) -> std::optional<fs::path> = {
	root_dir: std::optional<fs::path> = ();

	while !dir.empty() {
		if fs::exists(dir / "build.cpp2") { root_dir = dir; }
		parent_dir := dir.parent_path();
		if parent_dir == dir { break; }
		dir = parent_dir;
	}

	return root_dir;
}

find_build_cpp2_dir: (copy dir: fs::path) -> std::optional<fs::path> = {
	build_cpp2_dir: std::optional<fs::path> = ();

	while !dir.empty() {
		if fs::exists(dir / "build.cpp2") { return dir; }
		parent_dir := dir.parent_path();
		if parent_dir == dir { break; }
		dir = parent_dir;
	}

	return build_cpp2_dir;
}

build_binary_result: @struct type = {
	outpath: fs::path = ();
	exit_code: int = ();
	log_path: fs::path = ();
	duration: std::chrono::milliseconds = ();
}

cl_build_binary_cmd: (info: cpp2b_source_binary_info, bin_outpath: fs::path) -> std::string = {
	cppfront_include_dir := fs::absolute(".cache/cpp2/repos/hsutter/cppfront/include");
	transpiled_src := fs::absolute(".cache/cpp2/source") / fs::path(info.src).replace_extension(".cpp");
	d := fs::absolute(modules_dir());

	bin_parent_dir := fs::relative(bin_outpath).parent_path().string();
	std::replace(bin_parent_dir.begin(), bin_parent_dir.end(), '/', '\\');

	cmd_str: std::string = "cl /nologo /std:c++latest /W4 /MDd /EHsc /DEBUG:full /Zi /FC";
	for info.imports do (imp: std::string) {
		imp_bmi := d / ("(imp)$.ifc");
		imp_obj := d / ("(imp)$.obj");
		cmd_str += " /reference \"(imp_bmi.string())$\" \"(imp_obj.string())$\"";
	}
	cmd_str += " \"(transpiled_src.string())$\"";
	cmd_str += " -I\"(cppfront_include_dir.string())$\"";
	cmd_str += " /Fe\"(bin_outpath.string())$\"";
	cmd_str += " /Fo\"(bin_parent_dir)$\"";  // typos:disable-line
	cmd_str += " /Fd\"(bin_parent_dir)$\\\\\"";
	return cmd_str;
}

unix_build_binary_cmd: (compiler_cmd: std::string, info: cpp2b_source_binary_info, bin_outpath: fs::path) -> std::string = {
	sys_inc_dir := get_llvm_root() / "include" / "c++" / "v1";
	sys_lib_dir := get_llvm_root() / "lib";
	cppfront_include_dir := fs::absolute(".cache/cpp2/repos/hsutter/cppfront/include");
	transpiled_src := fs::absolute(".cache/cpp2/source") / fs::path(info.src).replace_extension(".cpp");
	d := fs::absolute(modules_dir());
	cmd_str: std::string = std::format("{} -stdlib=libc++ -fPIC", compiler_cmd);
	for info.imports do (imp: std::string) {
		cmd_str += " \"" + (d / ("(imp)$.pcm")).string() + "\"";
	}
	cmd_str += " \"(transpiled_src.string())$\"";
	cmd_str += " -std=c++23 -fexperimental-library";
	cmd_str += std::format(" -fprebuilt-module-path={}", d.string());
	cmd_str += std::format(" -L{}", sys_lib_dir.string());
	cmd_str += std::format(" -isystem {}", sys_inc_dir.string());
	cmd_str += " -lc++abi -lc++ -lm -static -fuse-ld=lld";
	cmd_str += " -I\"(cppfront_include_dir.string())$\"";
	cmd_str += " -o \"(bin_outpath.string())$\"";
	return cmd_str;
}


build_binary: (info: cpp2b_source_binary_info) -> build_binary_result = {
	compiler :== cpp2b::compiler();
	bin_basename: fs::path = info.name();
	if bin_basename.extension().empty() {
		bin_basename.replace_extension(executable_extension());
	}

	bin_outpath := fs::absolute(".cache/cpp2/bin") / bin_basename;
	log_path := fs::absolute(".cache/cpp2/log/compile") / fs::path(info.src).replace_extension(".log");
	ensure_dir(log_path.parent_path());
	ensure_dir(bin_outpath.parent_path());

	d := fs::absolute(modules_dir());

	cmd_str: std::string = "";
	     if compiler == cpp2b::compiler_type::msvc  { cmd_str = cl_build_binary_cmd(info, bin_outpath); }
	else if compiler == cpp2b::compiler_type::clang { cmd_str = unix_build_binary_cmd("clang-19", info, bin_outpath); }
	else if compiler == cpp2b::compiler_type::gcc   { cmd_str = unix_build_binary_cmd("gcc", info, bin_outpath); }
	else { log_error("Unsupported compiler"); std::exit(1); }

	cmd_str += " (cmd_log_output(fs::absolute(log_path)))$";

	result: build_binary_result = ();
	result.outpath = bin_outpath;
	result.exit_code = measure(:()=std::system(cmd_str$.c_str()), out result.duration);
	result.log_path = log_path;
	return result;
}

git_repo_clone_result: @struct type = {
	operations: std::string = "";
	exit_code: int = ();
	duration: std::chrono::milliseconds = ();
	log_path: fs::path = ();
}

git_clone_task: (repo: std::shared_ptr<cpp2b_detail_git_repo_impl>) -> git_repo_clone_result = {
	result: git_repo_clone_result = ();
	
	repo_path := cpp2b_detail_git_repo_path(repo.get());
	log_path := fs::absolute(std::format(
		".cache/cpp2/log/git_clone/{}/{}/{}.log",
		repo*.clone_host,
		repo*.clone_owner_dirname,
		repo*.clone_repo_dirname,
	));

	result.log_path = log_path;

	append_operation :=: (op: std::string) = {
		if !result&$*.operations.empty() {
			result&$*.operations += std::format(" + {}", op);
		} else {
			result&$*.operations += op;
		}
	};

	if !(repo_path / ".git").fs::exists() {
		ensure_dir(log_path.parent_path());

		append_operation("clone");

		cmd_str := std::format(
			"git clone {} {} {}",
			repo*.clone_url,
			fs::relative(repo_path).generic_string(),
			cmd_log_output(fs::relative(log_path)),
		);
		clone_duration: std::chrono::milliseconds;
		result.exit_code = measure(:()=std::system(cmd_str$.c_str()), out clone_duration);
		result.duration += clone_duration;
	}

	if result.exit_code != 0 { return result; }

	append_operation("checkout");

	cmd_str := std::format(
		"git -C {} checkout {} {}",
		fs::relative(repo_path).generic_string(),
		repo*.commitish,
		cmd_log_output(fs::relative(log_path)),
	);
	checkout_duration: std::chrono::milliseconds;
	result.exit_code = measure(:()=std::system(cmd_str$.c_str()), out checkout_duration);
	result.duration += checkout_duration;

	return result;
}

cpp2b_detail_build_impl: @struct type = {
	public build_cpp2_dir: fs::path;
	public bins: *std::vector<cpp2b_source_binary_info>;
	public git_repos: std::vector<std::shared_ptr<cpp2b_detail_git_repo_impl>>;
	public cpp1_modules: std::vector<std::shared_ptr<cpp2b_detail_cpp1_module_impl>>;
}
cpp2b_detail_build_binary_name: (
	copy impl: *cpp2b_detail_build_impl,
	copy rel_binary_src_path: std::filesystem::path,
	copy new_binary_name: std::string_view,
) = {
	build_cpp2_dir: fs::path = impl*.build_cpp2_dir;
	p := build_cpp2_dir / rel_binary_src_path;

	bin := std::ranges::find_if(
		impl*.bins*,
		:(bin)=fs::absolute(bin.src).replace_extension("") == fs::absolute(p$).replace_extension(""),
	);
	if bin == impl*.bins*..end() {
		log_warning("cannot name unknown binary target {}", p.generic_string());
		return;
	}

	bin*.preferred_name = (build_cpp2_dir / new_binary_name).generic_string();
}

cpp2b_detail_git_repo_impl: @struct type = {
	public clone_url: std::string = "";
	public commitish: std::string = "";

	public clone_host: std::string = "";
	public clone_owner_dirname: std::string = "";
	public clone_repo_dirname: std::string = "";
}

cpp2b_detail_cpp1_module_impl: @struct type = {
	public build_cpp2_dir: fs::path = ();
	public source_path: fs::path = ();
	public include_directories: std::vector<fs::path> = ();
	public system_include_directories: std::vector<fs::path> = ();
	public defines: std::unordered_map<std::string, std::string> = ();
	public has_error: bool = false;
}

cpp2b_detail_git_clone: (
	copy impl: *cpp2b_detail_build_impl,
	copy clone_url: std::string_view,
	copy commitish: std::string_view,
) -> std::shared_ptr<cpp2b_detail_git_repo_impl> = {
	repo_impl := cpp2::shared.new<cpp2b_detail_git_repo_impl>();

	repo_impl*.clone_url = clone_url;
	repo_impl*.commitish = commitish;


	m: git_clone_url_matcher = ();
	result := m.regex.match(repo_impl*.clone_url);
	
	repo_impl*.clone_host = result.group(1);
	repo_impl*.clone_owner_dirname = result.group(2);
	repo_impl*.clone_repo_dirname = result.group(3);

	impl*.git_repos.emplace_back(repo_impl);

	return repo_impl;
}

cpp2b_detail_git_repo_path: (
	copy impl: *const cpp2b_detail_git_repo_impl,
) -> fs::path = {
	return fs::absolute(std::format(
		".cache/cpp2/repos/{}/{}",
		impl*.clone_owner_dirname,
		impl*.clone_repo_dirname,
	));
}

cpp2b_detail_build: (copy _impl: *cpp2b_detail_build_impl) -> void = {
	// empty. this is just so we can decltype the signature
}

cl_build_build_script_cmd: (info: cpp2b_source_build_info, bin_outpath: fs::path) -> std::string = {
	cppfront_include_dir := fs::absolute(".cache/cpp2/repos/hsutter/cppfront/include");
	transpiled_src := fs::absolute(".cache/cpp2/source") / fs::path(info.src).replace_extension(".cpp");
	d := fs::absolute(modules_dir());
	cmd_str: std::string = "cl /nologo /std:c++latest /W4 /MDd /EHsc /LDd /DLL";
	for info.imports do (imp: std::string) {
		imp_bmi := d / ("(imp)$.ifc");
		imp_obj := d / ("(imp)$.obj");
		cmd_str += " /reference \"(imp_bmi.string())$\" \"(imp_obj.string())$\"";
	}
	cmd_str += " \"(transpiled_src .string())$\"";
	cmd_str += " -I\"(cppfront_include_dir.string())$\"";
	cmd_str += " /Fe\"(fs::relative(bin_outpath).string())$\"";
	cmd_str += " /Fo\"(fs::relative(bin_outpath).parent_path().string())$\""; // typos:disable-line
	cmd_str += " /link";
	return cmd_str;
}


unix_build_build_script_cmd: (compiler_cmd: std::string, info: cpp2b_source_build_info, bin_outpath: fs::path) -> std::string = {
	sys_inc_dir := get_llvm_root() / "include" / "c++" / "v1";
	sys_lib_dir := get_llvm_root() / "lib";
	cppfront_include_dir := fs::absolute(".cache/cpp2/repos/hsutter/cppfront/include");
	transpiled_src := fs::absolute(".cache/cpp2/source") / fs::path(info.src).replace_extension(".cpp");
	d := fs::absolute(modules_dir());
	cmd_str: std::string = std::format("{} -stdlib=libc++ -shared", compiler_cmd);
	for info.imports do (imp: std::string) {
		cmd_str += " \"" + (d / ("(imp)$.pcm")).string() + "\"";
	}
	cmd_str += " \"(transpiled_src.string())$\"";
	cmd_str += " -std=c++23 -fexperimental-library -fPIC";
	cmd_str += std::format(" -fprebuilt-module-path={}", d.string());
	cmd_str += std::format(" -L{}", sys_lib_dir.string());
	cmd_str += std::format(" -isystem {}", sys_inc_dir.string());
	cmd_str += " -lc++abi -lc++ -lm -fuse-ld=lld";
	cmd_str += " -I\"(cppfront_include_dir.string())$\"";
	cmd_str += " -o \"(bin_outpath.string())$\"";
	return cmd_str;
}


build_build_script: (info: cpp2b_source_build_info) -> build_binary_result = {
	compiler :== cpp2b::compiler();
	bin_outpath := fs::absolute(".cache/cpp2/bin") / fs::path(info.src).replace_extension(shared_library_extension());
	log_path := fs::absolute(".cache/cpp2/log/compile") / fs::path(info.src).replace_extension(".log");
	ensure_dir(log_path.parent_path());
	ensure_dir(bin_outpath.parent_path());

	d := fs::absolute(modules_dir());
	cmd_str: std::string = "";
	     if compiler == cpp2b::compiler_type::msvc  { cmd_str = cl_build_build_script_cmd(info, bin_outpath); }
	else if compiler == cpp2b::compiler_type::clang { cmd_str = unix_build_build_script_cmd("clang-19", info, bin_outpath); }
	else if compiler == cpp2b::compiler_type::gcc   { cmd_str = unix_build_build_script_cmd("gcc", info, bin_outpath); }
	else { log_error("Unsupported compiler"); std::exit(1); }

	cmd_str += " (cmd_log_output(fs::relative(log_path)))$";

	result: build_binary_result = ();
	result.outpath = bin_outpath;
	result.exit_code = measure(:()=std::system(cmd_str$.c_str()), out result.duration);
	result.log_path = log_path;
	return result;
}

print_log_file: (p: fs::path) -> void = {
	stream: std::ifstream = p;
	line: std::string = "";
	while std::getline(stream, line) {
		std::cerr << line << "\n";
	}
	stream.close();
}

assert_symbol: (d: dylib, symbol) = {
	if !d.has_symbol(symbol) {
		log_error("missing symbol '{}'", symbol);
		std::exit(1);
	}
}

full_build_info: @struct type = {
	bins: std::vector<cpp2b_source_binary_info> = ();
	mods: std::vector<cpp2b_source_module_info> = ();
	build_scripts: std::vector<cpp2b_source_build_info> = ();
	unknowns: std::vector<cpp2b_source_unknown_info> = ();

	bin_results: std::vector<build_binary_result> = ();

	empty: (this) -> bool = {
		return bin_results.empty();
	}
}

cpp2b_detail_create_cpp1_module: (
	copy impl: *cpp2b_detail_build_impl,
) -> std::shared_ptr<cpp2b_detail_cpp1_module_impl> = {
	cpp1_module_impl := cpp2::shared.new<cpp2b_detail_cpp1_module_impl>();
	
	cpp1_module_impl*.build_cpp2_dir = impl*.build_cpp2_dir;
	impl*.cpp1_modules.emplace_back(cpp1_module_impl);
	
	return cpp1_module_impl;
}

cpp2b_detail_cpp1_module_source_path: (
	copy impl: *cpp2b_detail_cpp1_module_impl,
	copy p: fs::path,
	copy caller_srcloc: std::source_location,
) -> void = {
	if p.is_relative() {
		// NOTE: msvc fails to compile this due to some cppfront zero check
		// p = impl*.build_cpp2_dir / p;
		p = unchecked_div(impl*.build_cpp2_dir, p);
	}

	if !impl*.source_path.empty() {
		impl*.has_error = true;
		log_error(caller_srcloc, "source path already set - only one source path is currently allowed for cpp1 modules");
	} else {
		impl*.source_path = p;
	}
}

cpp2b_detail_cpp1_module_include_directory: (
	copy impl: *cpp2b_detail_cpp1_module_impl,
	copy p: fs::path,
	copy caller_srcloc: std::source_location,
) -> void = {
	
	if impl*.include_directories.std::ranges::contains(p) {
		log_warning(caller_srcloc, "already added include directory {}", p.generic_string());
	} else if impl*.system_include_directories.std::ranges::contains(p) {
		log_warning(caller_srcloc, "already added system include directory {}", p.generic_string());
	} else {
		impl*.include_directories.emplace_back(p);
	}
}


cpp2b_detail_cpp1_module_system_include_directory: (
	copy impl: *cpp2b_detail_cpp1_module_impl,
	copy p: fs::path,
	copy caller_srcloc: std::source_location,
) -> void = {
	if impl*.include_directories.std::ranges::contains(p) {
		log_warning(caller_srcloc, "already added include directory {}", p.generic_string());
	} else if impl*.system_include_directories.std::ranges::contains(p) {
		log_warning(caller_srcloc, "already added system include directory {}", p.generic_string());
	} else {
		impl*.system_include_directories.emplace_back(p);
	}
}


cpp2b_detail_cpp1_module_define: (
	copy impl: *cpp2b_detail_cpp1_module_impl,
	copy name: std::string_view,
	copy value: std::string_view,
	copy caller_srcloc: std::source_location,
) -> void = {
	if impl*.defines.contains(std::string(name)) {
		impl*.has_error = true;
		current_definition_value := impl*.defines.at(std::string(name));
		log_error(caller_srcloc, "definition {} (with value {}) already added", name, current_definition_value);
	} else {
		impl*.defines[std::string(name)] = std::string(value);
	}
}


contains_target: (targets, value: std::string) -> bool = {
	for targets do(target: std::string) {
		if target == value { return true; }
		if value.starts_with(target + "/") { return true; }
	}
	return false;
}

do_build: (targets: std::vector<std::string>) -> (stuff: full_build_info, exit_code: int) = {
	build_cpp2_dir := fs::current_path();
	stuff = ();

	(repo := GitHubRepo("hsutter/cppfront", "v0.8.1")) { 
		repo.add("source");
		repo.add("include");
		exit_code = ensure_cppfront(repo.path());
		if exit_code != 0 { return; }
	}

	ensure_std_modules();
	generate_cpp2b_module();
	generate_cpp2b_build_module();

	transpile_source_dir: fs::path = ".cache/cpp2/source";
	cpp2_source_files: std::vector<fs::path> = ();
	ec: std::error_code = ();

	for fs::recursive_directory_iterator(transpile_source_dir) do(p: fs::path) {
		if p.extension() != ".cpp" { continue; }
		fs::permissions(p, fs::perms::others_write, fs::perm_options::add, ec);
		warn_if_error("perms", p, ec);
		fs::remove(p, ec);
		warn_if_error("remove", p, ec);
	}

	src_loop: for fs::recursive_directory_iterator(fs::current_path(), fs::directory_options::follow_directory_symlink) do(p: fs::path) {
		if p.extension() == ".cpp2" {
			rel_path := fs::relative(p, fs::current_path());
			for rel_path do(rel_path_comp) {
				if rel_path_comp.string().starts_with(".") {
					continue src_loop;
				}
			}

			cpp2_source_files.emplace_back(rel_path);
		}
	}

	if cpp2_source_files.empty() {
		log_error("No cpp2 source files");
		exit_code = 1;
		return;
	}

	transpile_futures: std::vector<std::future<transpile_cpp2_result>> = ();
	cpp2b_parse_futures: std::vector<std::future<cpp2b_source_info>> = ();
	transpile_futures.reserve(cpp2_source_files.size());
	cpp2b_parse_futures.reserve(cpp2_source_files.size());


	for cpp2_source_files do(src_file: fs::path) {
		transpile_futures.emplace_back(std::async(std::launch::async, transpile_cpp2, src_file, transpile_source_dir));
		cpp2b_parse_futures.emplace_back(std::async(std::launch::async, cpp2b_parse_source, src_file));
	}

	for transpile_futures do(inout fut) {
		info := fut.get();
		if info.cppfront_exit_code != 0 {
			log_error("cppfront exited with {} while transpiling {} - see log for full details {}", info.cppfront_exit_code, info.src.generic_string(), info.output_log.generic_string());
			exit_code = info.cppfront_exit_code;
			return;
		}

		log_info("transpile {} -> {} ({}ms)", info.src.generic_string(), info.cpp1_output.generic_string(), info.duration.count());
	}

	for cpp2b_parse_futures do(inout fut) {
		info := fut.get();
		if info.is_mod() {
			stuff.mods.emplace_back(info.mod());
		} else if info.is_bin() {
			stuff.bins.emplace_back(info.bin());
		} else if info.is_build() {
			stuff.build_scripts.emplace_back(info.build());
		} else {
			log_error("source file {} is neither a module or a binary source file", info.unknown().src.generic_string());
			stuff.unknowns.emplace_back(info.unknown());
		}
	}

	for fs::recursive_directory_iterator(transpile_source_dir) do(p: fs::path) {
		if p.extension() != ".cpp2" { continue; }
		fs::permissions(p, fs::perms::others_read, ec);
		warn_if_error("perms", p, ec);
	}

	built_modules: std::unordered_map<std::string, bool> = (
		std::pair("cpp2b", true),
		std::pair("cpp2b.build", true),
		std::pair("std", true),
		std::pair("std.compat", true),
	);

	build_script_futures: std::vector<std::pair<std::reference_wrapper<cpp2b_source_build_info>, std::future<build_binary_result>>> = ();
	build_script_futures.reserve(stuff.build_scripts.size());

	build_script_loop: for stuff.build_scripts do(inout build_script) {
		for build_script.imports do(imp) {
			if !built_modules.contains(imp) {
				log_error("cannot build build script {} - missing import {}", build_script.src.generic_string(), imp);
				continue build_script_loop;
			}
		}

		build_script_futures.emplace_back(
			std::ref(build_script),
			std::async(std::launch::async, build_build_script, build_script)
		);
	}

	git_repos: std::vector<std::shared_ptr<cpp2b_detail_git_repo_impl>> = ();
	cpp1_modules: std::vector<std::shared_ptr<cpp2b_detail_cpp1_module_impl>> = ();
	
	for build_script_futures do(inout p) {
		build_result := p.second.get();
		build_script := p.first.get();

		if build_result.exit_code != 0 {
			log_error("failed to build {} - exit code {}", build_script.src.generic_string(), build_result.exit_code);
			print_log_file(build_result.log_path);
			exit_code = build_result.exit_code;
			return;
		}

		log_info("build script built {} ({}ms)", fs::relative(build_result.outpath).generic_string(), build_result.duration.count());

		build_dylib := dylib(build_result.outpath);

		build_dylib.assert_symbol("cpp2b_detail_build");
		build_dylib.assert_symbol("cpp2b_detail_build_binary_name");
		build_dylib.assert_symbol("cpp2b_detail_cpp1_module_define");
		build_dylib.assert_symbol("cpp2b_detail_cpp1_module_include_directory");
		build_dylib.assert_symbol("cpp2b_detail_cpp1_module_source_path");
		build_dylib.assert_symbol("cpp2b_detail_cpp1_module_system_include_directory");
		build_dylib.assert_symbol("cpp2b_detail_create_cpp1_module");
		build_dylib.assert_symbol("cpp2b_detail_git_clone");
		build_dylib.assert_symbol("cpp2b_detail_git_repo_path");

		build_dylib.get_variable<decltype(cpp2b_detail_build_binary_name&)>("cpp2b_detail_build_binary_name") = cpp2b_detail_build_binary_name&;
		build_dylib.get_variable<decltype(cpp2b_detail_cpp1_module_define&)>("cpp2b_detail_cpp1_module_define") = cpp2b_detail_cpp1_module_define&;
		build_dylib.get_variable<decltype(cpp2b_detail_cpp1_module_include_directory&)>("cpp2b_detail_cpp1_module_include_directory") = cpp2b_detail_cpp1_module_include_directory&;
		build_dylib.get_variable<decltype(cpp2b_detail_cpp1_module_source_path&)>("cpp2b_detail_cpp1_module_source_path") = cpp2b_detail_cpp1_module_source_path&;
		build_dylib.get_variable<decltype(cpp2b_detail_cpp1_module_system_include_directory&)>("cpp2b_detail_cpp1_module_system_include_directory") = cpp2b_detail_cpp1_module_system_include_directory&;
		build_dylib.get_variable<decltype(cpp2b_detail_create_cpp1_module&)>("cpp2b_detail_create_cpp1_module") = cpp2b_detail_create_cpp1_module&;
		build_dylib.get_variable<decltype(cpp2b_detail_git_clone&)>("cpp2b_detail_git_clone") = cpp2b_detail_git_clone&;
		build_dylib.get_variable<decltype(cpp2b_detail_git_repo_path&)>("cpp2b_detail_git_repo_path") = cpp2b_detail_git_repo_path&;

		b: cpp2b_detail_build_impl = (
			build_script.src.parent_path(),
			stuff.bins&,
			:std::vector<std::shared_ptr<cpp2b_detail_git_repo_impl>>=(),
			:std::vector<std::shared_ptr<cpp2b_detail_cpp1_module_impl>>=(),
		);
		build_dylib.get_function<decltype(cpp2b_detail_build)>("cpp2b_detail_build")(b&);

		git_repos.append_range(b.git_repos);
		cpp1_modules.append_range(b.cpp1_modules);
	}

	git_repo_futures: std::vector<std::future<git_repo_clone_result>> = ();
	git_repo_futures.reserve(git_repos.size());
	
	if !git_repos.empty() {
		log_info("checking out {0} git repo(s)...", git_repos.size());
	}

	for git_repos do(git_repo) {
		git_repo_futures.emplace_back(
			std::async(std::launch::async, git_clone_task, git_repo)
		);
	}

	for std::ranges::views::zip(git_repo_futures, git_repos) do(copy p) {
		clone_res := std::get<0>(p).get();
		git_repo := std::get<1>(p);

		if clone_res.exit_code != 0 {
			log_error("failed to clone repo - exit code {}", clone_res.exit_code);
			print_log_file(clone_res.log_path);
			continue;
		}

		log_info("git {} for {} {} ({}ms)", clone_res.operations, git_repo*.clone_url, git_repo*.commitish, clone_res.duration.count());
	}

	for cpp1_modules do(copy cpp1m) {
		src_file := cpp1m*.source_path;
		
		if !src_file.fs::exists() {
			log_error("{} does not exist", src_file.generic_string());
			std::exit(1);
		}
	
		src_stream: std::ifstream = (src_file, std::ios_base::binary);
		
		if !src_stream.good() {
			log_error("failed to open {} - {}", src_file.generic_string(), cpp2b::os::get_last_error());
			std::exit(1);
		}

		result := cpp2b_parse_cpp1_module_statements(src_stream);

		if result.module_name.empty() {
			log_error("cannot find exported module in {}", src_file.generic_string());
			std::exit(1);
		}

		if !result.exported {
			log_error("module {} in {} must be exported", result.module_name, src_file.generic_string());
			std::exit(1);
		}
		
		build_cpp1_module(cpp1m*, result.module_name, result.imports);
		built_modules[result.module_name] = true;
	}

	for stuff.mods do(mod) {
		log_warning("cannot build user module {} (yet)", mod.name);
	}

	bin_targets: std::vector<std::string> = ();
	if !targets.empty() {
		bin_targets.reserve(targets.size());
	}

	bin_futures: std::vector<std::pair<std::reference_wrapper<cpp2b_source_binary_info>, std::future<build_binary_result>>> = ();
	bin_futures.reserve(stuff.bins.size());

	bin_loop: for stuff.bins do(inout bin) {
		bin_target_name := fs::path(bin.name()).generic_string();

		if !targets.empty() {
			if !targets.contains_target(bin_target_name) {
				continue bin_loop;
			}
		}

		bin_targets.emplace_back(bin_target_name);

		for bin.imports do(imp) {
			if !built_modules.contains(imp) {
				log_error("cannot build binary {} - missing import {}", bin.src.generic_string(), imp);
				continue bin_loop;
			}

			if imp == "cpp2b.build" {
				log_error("cpp2b.build module may only be imported in build.cpp files");
				continue bin_loop;
			}
		}

		bin_futures.emplace_back(
			std::ref(bin),
			std::async(std::launch::async, build_binary, bin)
		);
	}

	for bin_futures do(inout p) {
		build_result := p.second.get();
		bin := p.first.get();

		stuff.bin_results.emplace_back(build_result);

		if build_result.exit_code != 0 {
			log_error("failed to build binary - exit code {}", build_result.exit_code);
			print_log_file(build_result.log_path);
			continue;
		}

		log_success("binary built {} ({}ms)", fs::relative(build_result.outpath).generic_string(), build_result.duration.count());
	}

	for targets do (target: std::string) {
		if bin_targets.contains_target(target) {
			log_warning("requested target '{}' was not found", target);
		}
	}
	
	exit_code = 0;
}

subcommands: type = {
	clean: (args) -> int = {
		if !args.empty() {
			log_error("clean does not support arguments");
			return 1;
		}

		root_dir := find_root_dir(fs::current_path());
		if !root_dir {
			log_error("failed to find cpp2b project root directory - make sure you have build.cpp2 in the root of your project");
			return 1;
		}
		fs::current_path(root_dir*);

		cache_dir: fs::path = ".cache/cpp2";

		fs::remove_all(cache_dir);
		log_info("{} removed", fs::absolute(cache_dir).string());

		return 0;
	}
	
	build: (args) -> int = {
		cwd := fs::current_path();
		root_dir := find_root_dir(cwd);
		if !root_dir {
			log_error("failed to find cpp2b project root directory - make sure you have build.cpp2 in the root of your project");
			return 1;
		}

		cpp2b::env::set_var("CPP2B_PROJECT_ROOT", root_dir*.generic_string());

		targets: std::vector<std::string> = ();
		for args do(arg: std::string_view) {
			if arg.starts_with("-") {
				log_error("unknown flag {}", arg);
				return 1;
			}

			target :=  fs::path(arg)
				.fs::weakly_canonical()
				.fs::relative(root_dir*)
				.generic_string();

			if target.empty() {
				target = cwd.filename().generic_string();
			}

			targets.emplace_back(target);
		}

		if cwd != root_dir* {
			log_warning("root directory is {}", root_dir*.string());
			fs::current_path(root_dir*);
		}

		result := do_build(targets);

		for result.stuff.bin_results do(res) {
			if res.exit_code != 0 {
				result.exit_code = res.exit_code;
				log_error("failed to build {}", res.outpath.generic_string());
				print_log_file(res.log_path);
			}
		}

		if result.stuff.empty() {
			log_error("no targets built");
			return 1;
		}

		return result.exit_code;
	}

	run: (args) -> int = {
		cwd := fs::current_path();
		root_dir := find_root_dir(fs::current_path());
		if !root_dir {
			log_error("failed to find cpp2b project root directory - make sure you have build.cpp2 in the root of your project");
			return 1;
		}

		cpp2b::env::set_var("CPP2B_PROJECT_ROOT", root_dir*.generic_string());

		run_forward_args: std::vector<std::string> = ();
		target: std::optional<std::string> = ();
		(copy forward_args := false) for args do(arg: std::string_view) {
			if forward_args {
				run_forward_args.emplace_back(arg);
			} else if arg == "--" {
				forward_args = true;
			} else if arg.starts_with("-") {
				log_error("unknown flag {}", arg);
				return 1;
			} else if !target {
				target = fs::path(arg)
					.fs::weakly_canonical()
					.fs::relative(root_dir*)
					.generic_string();
				if target*.empty() {
					target = cwd.filename().generic_string();
				}
			} else {
				log_error("forward args must be placed after --");
				return 1;
			}
		}

		if cwd != root_dir* {
			log_warning("root directory is {}", root_dir*.string());
			fs::current_path(root_dir*);
		}

		if !target {
			target = cwd.filename().generic_string();
		}

		result := do_build(:std::vector=(target*));
		if result.exit_code != 0 { return result.exit_code; }

		for result.stuff.bin_results do(res) {
			if res.exit_code != 0 {
				result.exit_code = res.exit_code;
				log_error("failed to build {}", res.outpath.generic_string());
				print_log_file(res.log_path);
			}
		}

		if result.stuff.bin_results.empty() {
			log_error("no binary targets to run");
			return 1;
		}

		if result.stuff.bin_results.size() != 1 {
			log_error("more than one binary target found, cannot run");
			return 1;
		}

		bin_path := fs::relative(result.stuff.bin_results.at(0).outpath);
		log_info("running {}", bin_path.generic_string());
		run_cmd: std::string = bin_path.string();

		for run_forward_args do(fwd_arg) {
			run_cmd += " " + fwd_arg;
		}

		return std::system(run_cmd.c_str());
	}

	init: (args) -> int = {
		if fs::exists("build.cpp2") {
			log_error("already initialized cpp2b project!");
			return 1;
		}

		dirname := fs::current_path().filename().string();

		ensure_dir("src");

		main_cpp2: std::ofstream = ("src/main.cpp2", std::ios::binary);
		main_cpp2 << "main: () = std::println(\"Hello, (dirname)$!\");\n";

		build_cpp2: std::ofstream = ("build.cpp2", std::ios::binary);
		build_cpp2 << "import cpp2b.build;\n\n";
		build_cpp2 << "build: (inout b: cpp2b::build) -> void = {\n";
		build_cpp2 << "\t// rename binary so instead of it being 'src/main' it will be '(dirname)$'\n";
		build_cpp2 << "\tb.binary_name(\"src/main\", \"(dirname)$\");\n";
		build_cpp2 << "}\n";
		
		main_cpp2.flush();
		main_cpp2.close();
		build_cpp2.flush();
		build_cpp2.close();

		log_info("added build.cpp2");
		log_info("added src/main.cpp2");

		if !fs::exists(".gitignore") {
			if !find_git_root(fs::current_path()) {
				log_warning("assuming git repository");
			}

			gitignore: std::ofstream = (".gitignore", std::ios::binary);
			gitignore << "# cpp2b cache directory\n";
			gitignore << ".cache/cpp2\n";

			gitignore.flush();
			gitignore.close();

			log_info("added .gitignore");
		}

		log_success("initialized cpp2b project '{}'", dirname);
		log_info("run `cpp2b build` to build your project");

		return 0;
	}

	unknown: (subcommand) -> int = {
		log_error("unknown subcommand {}", subcommand);
		return 1;
	}
}

cpp2b_source_module_info: @struct type = {
	exported: bool = ();
	imports: std::vector<std::string> = ();
	name: std::string = ();
	partition: std::optional<std::string> = ();

	is_primary: (this) -> bool = !partition.has_value();
}

cpp2b_source_binary_info: @struct type = {
	src: fs::path = ();
	imports: std::vector<std::string> = ();
	preferred_name: std::optional<std::string> = ();

	name: (this) -> std::string = {
		bin_basename: fs::path;
		if this.preferred_name {
			bin_basename = fs::path(this.preferred_name*);
		} else {
			bin_basename = fs::path(this.src);
			while !bin_basename.extension().empty() {
				bin_basename.replace_extension("");
			}
		}
		return bin_basename.string();
	}
}

cpp2b_source_build_info: @struct type = {
	src: fs::path = ();
	imports: std::vector<std::string> = ();
}

cpp2b_source_unknown_info: @struct type = {
	src: fs::path;
}

cpp2b_source_info: @union type = {
	unknown: cpp2b_source_unknown_info;
	mod: cpp2b_source_module_info;
	bin: cpp2b_source_binary_info;
	build: cpp2b_source_build_info;
}

as_sv: (range) -> std::string_view = std::string_view(range.begin(), range.end());

ltrim: (str) -> std::string_view = {
	i:=0U; while str.size() > i next i++ {
		if !std::isspace(str[i]) { break; }
	}

	return std::string_view(str).substr(i, str.size() - i);
}

rtrim: (str) -> std::string_view = {
	i:=str.ssize()-1; while i > 0 next i-- {
		if !std::isspace(str[i]) { break; }
		if i == 0 { break; }
	}

	return std::string_view(str).substr(0, i + 1);
}

lstrip: (str, amount) -> std::string_view = {
	return std::string_view(str).substr(amount, str.size() - amount);
}

contains_any_whitespace: (str: std::string_view) -> bool = {
	for str do(c: char) {
		if std::isspace(c) {
			return true;
		}
	}
	return false;
}

cpp2b_parse_cpp1_module_statements: (copy stream: std::ifstream) -> (module_name: std::string, imports: std::vector<std::string>, exported: bool) = {
	assert(stream.good());

	statement: std::string = "";
	module_name = "";
	imports = ();
	exported = false;

	while std::getline(stream, statement) {
		trimmed_statement := statement.ltrim();
		kw_import: std::string_view == "import";
		kw_export: std::string_view == "export";
		kw_module: std::string_view == "module";

		if trimmed_statement.starts_with(kw_import) {
			import_name := trimmed_statement.lstrip(kw_import.size()).ltrim().rtrim();
			if !contains_any_whitespace(import_name) {
				imports.emplace_back(import_name);
			}
		}

		if trimmed_statement.starts_with(kw_export) {
			trimmed_statement = trimmed_statement.lstrip(kw_export.size()).ltrim();
			if !trimmed_statement.starts_with(kw_module) { continue; }

			found_mod_name := trimmed_statement.lstrip(kw_module.size()).ltrim();
			partition_start := module_name.find(':');
			if partition_start != std::string::npos {
				found_mod_name = found_mod_name.substr(0, partition_start).rtrim();
			} else {
				found_mod_name = found_mod_name.rtrim();
			}

			while !found_mod_name.empty() && (std::isspace(found_mod_name.back()) || found_mod_name.back() == ';') {
				found_mod_name = found_mod_name.substr(0, found_mod_name.size() - 1);
			}

			module_name = std::string(found_mod_name);
			exported = true;
			break;
		}
	}
}

cpp2b_parse_source: (source_file: fs::path) -> cpp2b_source_info = {
	stream: std::ifstream = source_file;
	statement: std::string = "";
	imports: std::vector<std::string> = ();

	// without this cppfront thinks stream is never used
	assert(stream);

	result: cpp2b_source_info = ();
	result.set_unknown(cpp2b_source_unknown_info(source_file));

	while std::getline(stream, statement, ';') {
		trimmed_statement := statement.ltrim();
		kw_import: std::string_view = "import";

		if trimmed_statement.starts_with(kw_import) {
			import_name := trimmed_statement.lstrip(kw_import.size()).ltrim().rtrim();
			if !contains_any_whitespace(import_name) {
				imports.emplace_back(import_name);
			}
		}
	}

	if std::ranges::find(imports, "std") == imports.end() {
		imports.emplace_back("std");
	}

	if std::ranges::find(imports, "std.compat") == imports.end() {
		imports.emplace_back("std.compat");
	}

	if source_file.filename() == "build.cpp2" {
		build_info: cpp2b_source_build_info = ();
		build_info.src = source_file;
		build_info.imports = imports;
		result.set_build(build_info);
		return result;
	}

	stream.clear();
	stream.seekg(0);

	while std::getline(stream, statement, ';') {
		trimmed_statement := statement.ltrim();
		kw_export: std::string_view = "export";
		kw_module: std::string_view = "module";

		if trimmed_statement.starts_with(kw_export) {
			trimmed_statement = trimmed_statement.lstrip(kw_export.size()).ltrim();
			if !trimmed_statement.starts_with(kw_module) { break; }

			module_name := trimmed_statement.lstrip(kw_module.size()).ltrim();
			partition_start := module_name.find(':');
			if partition_start != std::string::npos {
				module_name = module_name.substr(0, partition_start).rtrim();
			} else {
				module_name = module_name.rtrim();
			}

			mod_info: cpp2b_source_module_info = ();

			mod_info.name = std::string(module_name);
			mod_info.imports = imports;
			mod_info.exported = true;

			result.set_mod(mod_info);
			return result;
		}
	}

	stream.clear();
	stream.seekg(0);

	line: std::string = ();
	while std::getline(stream, line) {
		trimmed_line := line.ltrim();
		if trimmed_line.starts_with("main") {
			after_main := trimmed_line.substr(4).ltrim();
			if after_main.empty() || after_main[0] == ':' {
				bin_info: cpp2b_source_binary_info = ();
				bin_info.src = source_file;
				bin_info.imports = imports;
				result.set_bin(bin_info);
				return result;
			}
		}
	}

	return result;
}