Crafter.Build/implementations/Crafter.Build-Implementation.cpp

// SPDX-License-Identifier: LGPL-3.0-only
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®

module Crafter.Build:Implementation_impl;
import std;
import :Implementation;
import :Interface;
import :Platform;
namespace fs = std::filesystem;

namespace Crafter {
    Implementation::Implementation(fs::path&& path) : path(std::move(path)) {

    }
    bool Implementation::Check(const fs::path& buildDir, const fs::path& pcmDir, fs::file_time_type sourceFloor) const {
        std::string objPath = std::format("{}_impl.o", (buildDir/path.filename()).string());
        std::string cppPath = std::format("{}.cpp", path.string());
        // The depfile clang wrote beside the object lists the headers this TU
        // included; nothing else in the configuration knows about them, since
        // the source scanner only reads `import` lines.
        if(!fs::exists(objPath) || std::max({fs::last_write_time(cppPath), sourceFloor, NewestPrerequisite(std::format("{}.d", objPath))}) >= fs::last_write_time(objPath)) {
            return true;
        }
        fs::file_time_type objTime = fs::last_write_time(objPath);
        for(ModulePartition* dependency : partitionDependencies) {
            if(dependency->Check(pcmDir, sourceFloor)) return true;
        }
        for(Module* dependency : moduleDependencies) {
            if(dependency->Check(pcmDir, sourceFloor)) return true;
        }
        for(const auto& [externalMod, externalPcmPath] : externalModuleDependencies) {
            std::error_code ec;
            fs::file_time_type pcmTime = fs::last_write_time(externalPcmPath, ec);
            if (!ec && pcmTime >= objTime) return true;
        }
        return false;
    }
    void Implementation::Compile(const std::string_view clang, const fs::path& buildDir, std::atomic<bool>& buildCancelled, std::string& buildError) const {
        for(ModulePartition* dependency : partitionDependencies) {
            if(!dependency->compiled.load()) {
                dependency->compiled.wait(false);
            }
        }
        for(Module* dependency : moduleDependencies) {
            if(!dependency->compiled.load()) {
                dependency->compiled.wait(false);
            }
        }

        if (buildCancelled.load(std::memory_order_relaxed)) {
            return;
        }

        // -MD leaves <name>_impl.o.d beside the object for Check to read.
        std::string result = RunBuildCommand(std::format("{0} {1}.cpp -c -MD -MF {2}_impl.o.d -o {2}_impl.o", clang, path.string(), (buildDir/path.filename()).string()));

        bool expected = false;
        if(!result.empty() && buildCancelled.compare_exchange_strong(expected, true)) {
            buildError = std::move(result);
        }
    }
}