Crafter.Build/project.cpp

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

import std;
import Crafter.Build;
#pragma crafter dependency "https://forgejo.catcrafts.net/Catcrafts/Crafter.LintRules.git"
import Crafter.LintRules;
namespace fs = std::filesystem;
using namespace Crafter;

extern "C" Configuration CrafterBuildProject(std::span<const std::string_view> args) {
    std::vector<std::string> depArgs(args.begin(), args.end());
    Configuration* math = GitProject({
        .source = { "https://forgejo.catcrafts.net/Catcrafts/Crafter.Math.git" },
        .args = depArgs,
    });
    Configuration* asset = GitProject({
        .source = { "https://forgejo.catcrafts.net/Catcrafts/Crafter.Asset.git" },
        .args = depArgs,
    });

    static auto CrafterBuildLib = std::make_unique<Configuration>();
    CrafterBuildLib->path = "./";
    CrafterBuildLib->name = "crafter.build-lib";
    CrafterBuildLib->outputName = "crafter-build";
    ApplyStandardArgs(*CrafterBuildLib, args);
    // Monolithic: project.so resolves Crafter:: symbols from the running
    // executable, so the library is only ever linked statically into it.
    CrafterBuildLib->type = ConfigurationType::LibraryStatic;

    CrafterBuildLib->dependencies = { math, asset };
    CrafterBuildLib->defines.push_back({"CRAFTER_BUILD_HAS_ASSET", ""});
    // Crafter.Build-Lint includes libclang's clang-c/Index.h, which is only
    // on the default include path for a toolchain installed in /usr.
    if (const fs::path& llvmInclude = GetToolchain().llvmIncludeDir; !llvmInclude.empty()) {
        CrafterBuildLib->compileFlags.push_back(std::format("-I{}", llvmInclude.string()));
    }
    // The version the binary reports: CI sets it from the tag, a checkout
    // describes itself, anything else is a development build. A define on
    // the library, so each version is its own library variant.
    std::string version;
    if (const char* env = std::getenv("CRAFTER_BUILD_VERSION"); env && *env) {
        version = env;
    } else {
        auto described = RunCommandWithTimeout("git describe --tags --always --dirty --exclude=latest 2>/dev/null", std::chrono::seconds(10));
        version = described.output;
        while (!version.empty() && (version.back() == '\n' || version.back() == '\r')) version.pop_back();
        if (described.exitCode != 0 || version.empty()) version = "0.0.0-dev";
    }
    // Backslash-escaped quotes: the define travels through the shell before
    // it reaches clang, which must still see a string literal.
    CrafterBuildLib->defines.push_back({"CRAFTER_BUILD_VERSION", std::format("\\\"{}\\\"", version)});
    {
        std::array<fs::path, 13> interfaces = {
            "interfaces/Crafter.Build",
            "interfaces/Crafter.Build-Toolchain",
            "interfaces/Crafter.Build-Shader",
            "interfaces/Crafter.Build-Platform",
            "interfaces/Crafter.Build-Interface",
            "interfaces/Crafter.Build-Implementation",
            "interfaces/Crafter.Build-External",
            "interfaces/Crafter.Build-Clang",
            "interfaces/Crafter.Build-Test",
            "interfaces/Crafter.Build-Lint",
            "interfaces/Crafter.Build-Script",
            "interfaces/Crafter.Build-Progress",
            "interfaces/Crafter.Build-Asset",
        };
        std::array<fs::path, 12> implementations = {
            "implementations/Crafter.Build-Toolchain",
            "implementations/Crafter.Build-Shader",
            "implementations/Crafter.Build-Platform",
            "implementations/Crafter.Build-Interface",
            "implementations/Crafter.Build-Implementation",
            "implementations/Crafter.Build-External",
            "implementations/Crafter.Build-Clang",
            "implementations/Crafter.Build-Test",
            "implementations/Crafter.Build-Lint",
            "implementations/Crafter.Build-Script",
            "implementations/Crafter.Build-Progress",
            "implementations/Crafter.Build-Asset",
        };
        CrafterBuildLib->GetInterfacesAndImplementations(interfaces, implementations);
    }
    ExternalDependency& glslang = CrafterBuildLib->externalDependencies.emplace_back();
    glslang.name = "glslang";
    glslang.source.url = "https://github.com/KhronosGroup/glslang.git";
    glslang.source.branch = "main";
    glslang.builder = ExternalBuilder::CMake;
    glslang.options = { "-DENABLE_OPT=OFF" };
    glslang.includeDirs = { "" };
    glslang.libs = { "SPIRV", "GenericCodeGen", "glslang", "OSDependent", "MachineIndependent", "glslang-default-resource-limits" };

    Configuration cfg;
    cfg.path = "./";
    cfg.name = "crafter.build-exe";
    cfg.outputName = "crafter-build";
    ApplyStandardArgs(cfg, args);
    cfg.type = ConfigurationType::Executable;
    cfg.dependencies = { CrafterBuildLib.get() };
    {
        std::array<fs::path, 0> interfaces = {};
        std::array<fs::path, 1> implementations = { "implementations/main" };
        cfg.GetInterfacesAndImplementations(interfaces, implementations);
    }
    // Linux hosts, glibc or musl (Alpine): -ldl is a libc stub on musl, harmless.
    const bool linuxTarget = cfg.target.ends_with("-linux-gnu") || cfg.target.ends_with("-linux-musl");
    if (linuxTarget) {
        cfg.linkFlags.push_back("-Wl,--export-dynamic");
        cfg.linkFlags.push_back("-ldl");
    }

    // Self-tests link the local crafter-build library and exercise it in
    // process. The harness (whichever crafter-build invokes `test`) compiles
    // these against the *installed* share/crafter-build .cppm files, then
    // links each test exe against CrafterBuildLib built from the local
    // sources — so the code under test is whatever's in this checkout.
    // Mirrors how downstream consumers link their own libraries into tests.
    if (linuxTarget) {
        cfg.AddTest("HelloWorld").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("StaticLib").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("ModuleInterface").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("DependencyLink").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("IncrementalInterfaceChange").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("TransitiveInterfaceChange").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("IncrementalHeaderChange").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("CompilerWarning").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("CleanProject").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("ShaderCompile").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("ShaderVariantBuild").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("StandardArgs").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("TestRunnerSpec").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("VariantId").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("ToolchainResolve").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("SysrootStdModule").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("SysrootCompileFlags").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("VersionFlag").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("WasiBrowserRuntime").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("WasmVariants").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("WasmHelloRuns").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("RunSingleTestExit").Dependencies({ CrafterBuildLib.get() });
        // LoadProject dlopens the synthesized project.so, which references
        // Crafter:: symbols (HostTarget, Configuration ctors) that have to be
        // visible from the test exe — same wiring crafter-build itself uses
        // for project.so.
        cfg.AddTest("ConcurrentCacheRace").Dependencies({ CrafterBuildLib.get() })
            .LinkFlag("-Wl,--export-dynamic").LinkFlag("-ldl");
        // Same LoadProject wiring as ConcurrentCacheRace above.
        cfg.AddTest("HostCacheSourceStamp").Dependencies({ CrafterBuildLib.get() })
            .LinkFlag("-Wl,--export-dynamic").LinkFlag("-ldl");
        cfg.AddTest("HostCacheToolchainKey").Dependencies({ CrafterBuildLib.get() })
            .LinkFlag("-Wl,--export-dynamic").LinkFlag("-ldl");
        cfg.AddTest("ProjectDependency").Dependencies({ CrafterBuildLib.get() })
            .LinkFlag("-Wl,--export-dynamic").LinkFlag("-ldl");
        cfg.AddTest("Script").Dependencies({ CrafterBuildLib.get() })
            .LinkFlag("-Wl,--export-dynamic").LinkFlag("-ldl");
        cfg.AddTest("ConcurrentDependencyReset").Dependencies({ CrafterBuildLib.get() });
        cfg.AddTest("Lint").Dependencies({ CrafterBuildLib.get() });
    }

    // Dogfood: the house-style rules, imported from their own repo through
    // the pragma above. Report rules gate `crafter-build lint`; transform
    // rules also auto-fix under `crafter-build format`.
    LintRules::AddRules(cfg);

    return cfg;
}