From 17021c6055cfc7efee297fadbfff1c53b1403ef4 Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 02:56:14 +0100 Subject: [PATCH 01/12] feat(external): forward a project's args to its sibling projects by default Every project.cpp with a sibling dependency opened with the same line, std::vector depArgs(args.begin(), args.end()); and handed depArgs to each GitProject and LocalProject. CrafterBuildProject receives a span of string_views and the specs wanted owned strings, and without the copy the sibling got none of the project's args: it was built for the host while the project cross-compiled, and in release while it built --debug. GitProject then turned the copy straight back into string_views for LoadProject. Both specs now default their args to ProjectArgs(), the args LoadProject was given for the project file whose CrafterBuildProject is running. It reads the per-thread stack LoadProject already keeps for IsTopLevelProject and ProjectDependency, whose frames now record the args. A default member initializer rather than a new type or an optional: the member stays a std::vector, so every existing `.args = depArgs` keeps its exact meaning (each of the ~50 calls across the Catcrafts projects passes one), and `.args = {}` still forwards nothing. It is the shape of Configuration::target = HostTarget(). A project.cpp that drops its .args needs a crafter-build with this change: an older one compiles it and forwards nothing. ProjectArgs() is declared in :External, next to the defaults that call it. :Platform, where it is defined, cannot be imported there: its unexported `struct Configuration;` would make :External's exported one an ill-formed redeclaration, which clang rejects. The #pragma crafter dependency path now passes `.args = {}` explicitly. Host tooling is built for the host whatever the consumer targets and was loaded with no args; the default would otherwise hand it the consumer's --target= and project flags. Co-Authored-By: Claude Opus 5.5 --- implementations/Crafter.Build-Platform.cpp | 36 +++++++++++++++++----- interfaces/Crafter.Build-External.cppm | 25 ++++++++++++--- 2 files changed, 48 insertions(+), 13 deletions(-) diff --git a/implementations/Crafter.Build-Platform.cpp b/implementations/Crafter.Build-Platform.cpp index e4ead32..1d21c9c 100644 --- a/implementations/Crafter.Build-Platform.cpp +++ b/implementations/Crafter.Build-Platform.cpp @@ -413,6 +413,10 @@ namespace { struct ProjectFileFrame { fs::path project; + // What LoadProject was given, for ProjectArgs(). A view is enough: + // the caller's storage outlives LoadProject, and the frame is popped + // before LoadProject returns. + std::span args; std::vector dependencies; }; @@ -426,7 +430,10 @@ namespace { // already on the stack is a cycle, which used to recurse forever. class ProjectFileGuard { public: - explicit ProjectFileGuard(const fs::path& absProject) { + // The args are recorded with the frame rather than just before + // CrafterBuildProject runs, so a spec built while dlopen runs the + // project file's static initialisers sees them too. + ProjectFileGuard(const fs::path& absProject, std::span args) { for (const ProjectFileFrame& frame : LoadingFrames) { if (frame.project != absProject) continue; std::string chain; @@ -434,7 +441,7 @@ namespace { throw std::runtime_error(std::format("circular project dependency: {}{}", chain, absProject.string())); } index_ = LoadingFrames.size(); - LoadingFrames.push_back({ absProject, {} }); + LoadingFrames.push_back({ absProject, args, {} }); } ~ProjectFileGuard() { LoadingFrames.pop_back(); } ProjectFileGuard(const ProjectFileGuard&) = delete; @@ -451,8 +458,9 @@ namespace { // same PCM cache LoadProject populates — the hostConfig LoadProject itself // compiles project.so with, so the dependency's std/Crafter.Build PCMs // land in the cache dir project.so is built against. Recursive, because - // the dependency's project.cpp forwards no arguments but still reads - // CRAFTER_BUILD_MARCH from the environment for its own deps. + // the dependency's project.cpp is loaded with no arguments and so passes + // none on, while its own deps still read CRAFTER_BUILD_MARCH from the + // environment. void ForceHostTooling(Configuration& cfg, const Configuration& host, std::unordered_set& seen) { if (!seen.insert(&cfg).second) return; cfg.target = host.target; @@ -495,10 +503,16 @@ namespace { std::set libs; for (const PragmaDependency& pragma : pragmas) { + // Host tooling is loaded with none of the consumer's args, so both + // specs pass `.args = {}` instead of defaulting to them. The tool + // is built for the host whatever the consumer targets: given the + // consumer's --target=, its project.cpp would pick sources and + // flags for the wrong triple before ForceHostTooling resets the + // fields, and the consumer's own flags would hash it apart from + // the build every other consumer of the tool shares. Configuration* cfg = nullptr; if (IsGitSource(pragma.source)) { - GitProjectSpec spec; - spec.source = { pragma.source, pragma.branch, pragma.commit }; + GitProjectSpec spec{ .source = { pragma.source, pragma.branch, pragma.commit }, .args = {} }; if (!pragma.project.empty()) spec.projectFile = pragma.project; cfg = GitProject(spec); } else { @@ -512,7 +526,7 @@ namespace { PragmaError(absProject, pragma.line, "'project' only applies to a directory source"); } if (!fs::exists(local)) PragmaError(absProject, pragma.line, std::format("no such project file: {}", local.string())); - cfg = LocalProject({ .projectFile = local }); + cfg = LocalProject({ .projectFile = local, .args = {} }); } if (std::ranges::contains(out.configs, cfg)) continue; @@ -580,6 +594,12 @@ bool Crafter::IsTopLevelProject() { return LoadingFrames.size() <= 1; } +std::vector Crafter::ProjectArgs() { + if (LoadingFrames.empty()) return {}; + const std::span args = LoadingFrames.back().args; + return std::vector(args.begin(), args.end()); +} + namespace { // The one reading of a wait status (pclose, system) for every helper // that runs a command: a signal death is reported the way a shell @@ -882,7 +902,7 @@ namespace { Configuration Crafter::LoadProject(const fs::path& projectFile, std::span args) { RequireToolchain(); fs::path absProject = fs::canonical(projectFile); - ProjectFileGuard guard(absProject); + ProjectFileGuard guard(absProject, args); fs::path buildDir = absProject.parent_path() / "build"; if (!fs::exists(buildDir)) { fs::create_directories(buildDir); diff --git a/interfaces/Crafter.Build-External.cppm b/interfaces/Crafter.Build-External.cppm index d415587..f33cb3d 100644 --- a/interfaces/Crafter.Build-External.cppm +++ b/interfaces/Crafter.Build-External.cppm @@ -71,16 +71,31 @@ export namespace Crafter { // clone can still differ in includeDirs, libDirs and libs. ExternalBuildResult ExternalOutputs(const ExternalDependency& dep, std::string_view target); + // The args LoadProject was given for the project file currently running + // its CrafterBuildProject: what that function receives, standard flags + // included (cfg.projectArgs is only the part ApplyStandardArgs left + // over). Empty when no project file is running, and on any thread but + // the one loading it, because it reads the stack LoadProject keeps per + // thread, as IsTopLevelProject does. The specs below default their args + // to it. Defined beside LoadProject, but declared here so those defaults + // can see it: importing :Platform into this partition would make the + // exported `struct Configuration;` above a redeclaration of :Platform's + // unexported one, which clang rejects. + std::vector ProjectArgs(); + // Specification for a sibling crafter-build project to fetch and depend on. // GitSource picks the revision: leave branch + commit empty for the // remote's default branch HEAD (sloppy but convenient), set branch to // track a branch tip, or set commit to pin to an immutable SHA. args are - // forwarded verbatim to the dep's CrafterBuildProject — typically you - // pass through the parent's args so target/march/debug propagate. + // what the dep's CrafterBuildProject receives. They default to this + // project's own, so --target=, --march=, --debug and flags of its own + // such as --local reach a whole chain of sibling projects without being + // passed. Set them to forward something else: a copy without one of this + // project's flags, one with an extra --target=, or {} for nothing. struct GitProjectSpec { GitSource source; fs::path projectFile = "project.cpp"; - std::vector args; + std::vector args = ProjectArgs(); }; // Clones the spec's git URL into the per-project external cache (keyed by @@ -94,8 +109,8 @@ export namespace Crafter { // example folder depending on its parent project, or a workspace where // multiple projects live side-by-side without going through git). struct LocalProjectSpec { - fs::path projectFile; // relative to cwd or absolute - std::vector args; // forwarded to dep's CrafterBuildProject + fs::path projectFile; // relative to cwd or absolute + std::vector args = ProjectArgs(); // as GitProjectSpec::args }; // Same as GitProject but for a local on-disk project — no fetch, no From 3ad19510570b9e31ff429f7d17aa450066e416be Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 02:56:15 +0100 Subject: [PATCH 02/12] test: sibling projects inherit the loading project's args ProjectArgs loads a chain app -> lib -> leaf of LocalProjects with --debug and a project flag. lib, loaded without .args, has to see both, and so does its own sibling, which takes the default one level further down. Copies loaded with `.args = {}` and with an explicit list get nothing and exactly that list. The GitProjectSpec default is checked on the spec itself, since a GitProject would need a repository to clone. Without the defaults, five of its checks fail. ProjectDependency now also loads its consumer with a project flag: the pragma dependency must still come back with no args. Without the explicit `.args = {}` in the pragma path it gets the consumer's flag. Co-Authored-By: Claude Opus 5.5 --- project.cpp | 2 + tests/ProjectArgs/fixture/app/project.cpp | 29 +++++++ tests/ProjectArgs/fixture/leaf/project.cpp | 17 ++++ tests/ProjectArgs/fixture/lib/project.cpp | 21 +++++ tests/ProjectArgs/main.cpp | 91 ++++++++++++++++++++++ tests/ProjectDependency/main.cpp | 15 ++++ 6 files changed, 175 insertions(+) create mode 100644 tests/ProjectArgs/fixture/app/project.cpp create mode 100644 tests/ProjectArgs/fixture/leaf/project.cpp create mode 100644 tests/ProjectArgs/fixture/lib/project.cpp create mode 100644 tests/ProjectArgs/main.cpp diff --git a/project.cpp b/project.cpp index af83a8d..d3771f8 100644 --- a/project.cpp +++ b/project.cpp @@ -287,6 +287,8 @@ extern "C" Configuration CrafterBuildProject(std::span a .LinkFlag("-Wl,--export-dynamic").LinkFlag("-ldl"); cfg.AddTest("ProjectDependency").Dependencies({ CrafterBuildLib.get() }) .LinkFlag("-Wl,--export-dynamic").LinkFlag("-ldl"); + cfg.AddTest("ProjectArgs").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() }); diff --git a/tests/ProjectArgs/fixture/app/project.cpp b/tests/ProjectArgs/fixture/app/project.cpp new file mode 100644 index 0000000..353c592 --- /dev/null +++ b/tests/ProjectArgs/fixture/app/project.cpp @@ -0,0 +1,29 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Crafter.Build; +using namespace Crafter; + +// Loads the same sibling three ways: with its args left at their default, +// with nothing forwarded, and with a list of its own. The test reads what +// each copy received back out of cfg.dependencies. +extern "C" Configuration CrafterBuildProject(std::span args) { + Configuration* inherited = LocalProject({ .projectFile = "../lib/project.cpp" }); + Configuration* none = LocalProject({ .projectFile = "../lib/project.cpp", .args = {} }); + Configuration* replaced = LocalProject({ .projectFile = "../lib/project.cpp", .args = { "--only" } }); + + Configuration cfg; + cfg.path = "./"; + cfg.name = "app"; + cfg.outputName = "app"; + cfg.type = ConfigurationType::Executable; + ApplyStandardArgs(cfg, args); + cfg.dependencies = { inherited, none, replaced }; + // GitProjectSpec takes the same default. Checked on the spec itself, + // since a GitProject would need a repository to clone. + const GitProjectSpec git{ .source = { .url = "unused" } }; + const bool gitDefault = git.args == std::vector(args.begin(), args.end()); + cfg.compileFlags.push_back(gitDefault ? "-DGIT_DEFAULT=1" : "-DGIT_DEFAULT=0"); + return cfg; +} diff --git a/tests/ProjectArgs/fixture/leaf/project.cpp b/tests/ProjectArgs/fixture/leaf/project.cpp new file mode 100644 index 0000000..15b16d4 --- /dev/null +++ b/tests/ProjectArgs/fixture/leaf/project.cpp @@ -0,0 +1,17 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Crafter.Build; +using namespace Crafter; + +// The end of the chain: records what it was loaded with and nothing else. +extern "C" Configuration CrafterBuildProject(std::span args) { + Configuration cfg; + cfg.path = "./"; + cfg.name = "leaf"; + cfg.outputName = "leaf"; + cfg.type = ConfigurationType::LibraryStatic; + ApplyStandardArgs(cfg, args); + return cfg; +} diff --git a/tests/ProjectArgs/fixture/lib/project.cpp b/tests/ProjectArgs/fixture/lib/project.cpp new file mode 100644 index 0000000..f1702c9 --- /dev/null +++ b/tests/ProjectArgs/fixture/lib/project.cpp @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Crafter.Build; +using namespace Crafter; + +// The middle of the chain. Its own sibling takes the default too, so +// whatever this file was loaded with has to reach the leaf unchanged. +extern "C" Configuration CrafterBuildProject(std::span args) { + Configuration* leaf = LocalProject({ .projectFile = "../leaf/project.cpp" }); + + Configuration cfg; + cfg.path = "./"; + cfg.name = "lib"; + cfg.outputName = "lib"; + cfg.type = ConfigurationType::LibraryStatic; + ApplyStandardArgs(cfg, args); + cfg.dependencies = { leaf }; + return cfg; +} diff --git a/tests/ProjectArgs/main.cpp b/tests/ProjectArgs/main.cpp new file mode 100644 index 0000000..4b47938 --- /dev/null +++ b/tests/ProjectArgs/main.cpp @@ -0,0 +1,91 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Crafter.Build; +namespace fs = std::filesystem; +using namespace Crafter; + +// A GitProject or LocalProject without `.args` forwards the args of the +// project file that declares it: both specs default their args to +// ProjectArgs(). Before that default, every project.cpp with a sibling +// dependency copied its span into a std::vector for each spec, +// and a spec that missed the copy built its sibling with none of the +// project's flags: for the host while the project cross-compiled, and in +// release while the project built --debug. The fixture is a chain +// app -> lib -> leaf of LocalProjects; app also loads lib with an empty and +// with a replaced list, and checks the GitProjectSpec default itself, which +// a clone would need a repository for. +namespace { + std::int32_t Failures = 0; + + void Check(bool cond, std::string_view msg) { + if (!cond) { + std::println(std::cerr, "FAIL: {}", msg); + ++Failures; + } + } + + // The single sibling lib and leaf declare, or nullptr. + const Configuration* OnlyDependency(const Configuration& cfg) { + return cfg.dependencies.size() == 1 ? cfg.dependencies[0] : nullptr; + } +} + +int main() { + const fs::path installedHome = GetCrafterBuildHome(); + if (!fs::exists(installedHome / "Crafter.Build.cppm")) { + std::println(std::cerr, "SKIP: no module sources at {}", installedHome.string()); + return 77; + } + + // Staged because LoadProject drops a build/ tree next to every project + // file it compiles. + const fs::path fixture = fs::current_path() / "tests" / "ProjectArgs" / "fixture"; + const fs::path scratch = fs::temp_directory_path() / "crafter-build-project-args"; + std::error_code ec; + fs::remove_all(scratch, ec); + fs::create_directories(scratch); + fs::copy(fixture, scratch, fs::copy_options::recursive); + + Check(ProjectArgs().empty(), "no project args outside a project file"); + + // Loaded from the project's own directory, as crafter-build runs it: the + // fixture's LocalProject paths are relative to the working directory. + const fs::path cwd = fs::current_path(); + fs::current_path(scratch / "app"); + std::array args = { "--debug", "--flavor=x" }; + const std::vector flavor = { "--flavor=x" }; + const std::vector only = { "--only" }; + try { + Configuration cfg = LoadProject("project.cpp", args); + Check(std::ranges::contains(cfg.compileFlags, "-DGIT_DEFAULT=1"), "a GitProjectSpec's args default to the project's own"); + Check(cfg.dependencies.size() == 3, std::format("the project declared its three siblings (got {})", cfg.dependencies.size())); + if (cfg.dependencies.size() == 3) { + const Configuration& inherited = *cfg.dependencies[0]; + const Configuration& none = *cfg.dependencies[1]; + const Configuration& replaced = *cfg.dependencies[2]; + Check(inherited.debug && inherited.projectArgs == flavor, std::format("a LocalProject without .args gets the project's args (debug {}, projectArgs {})", inherited.debug, inherited.projectArgs)); + Check(!none.debug && none.projectArgs.empty(), std::format("`.args = {{}}` forwards nothing (debug {}, projectArgs {})", none.debug, none.projectArgs)); + Check(!replaced.debug && replaced.projectArgs == only, std::format("an explicit list replaces the args rather than adding to them (debug {}, projectArgs {})", replaced.debug, replaced.projectArgs)); + Check(&inherited != &none && &inherited != &replaced && &none != &replaced, "each list loads its own configuration"); + + // One sibling further down, the same default passes on what the + // middle project was given, not what the top one was. + const Configuration* inheritedLeaf = OnlyDependency(inherited); + Check(inheritedLeaf && inheritedLeaf->debug && inheritedLeaf->projectArgs == flavor, "the project's args reach its sibling's sibling"); + const Configuration* noneLeaf = OnlyDependency(none); + Check(noneLeaf && !noneLeaf->debug && noneLeaf->projectArgs.empty(), "a sibling loaded with nothing passes nothing on"); + const Configuration* replacedLeaf = OnlyDependency(replaced); + Check(replacedLeaf && !replacedLeaf->debug && replacedLeaf->projectArgs == only, "a sibling passes on the list it was given"); + } + } catch (const std::exception& e) { + fs::current_path(cwd); + std::println(std::cerr, "FAIL: LoadProject threw: {}", e.what()); + return 1; + } + fs::current_path(cwd); + + Check(ProjectArgs().empty(), "no project args once the project file has returned"); + return Failures > 0 ? 1 : 0; +} diff --git a/tests/ProjectDependency/main.cpp b/tests/ProjectDependency/main.cpp index fcf1c57..de01130 100644 --- a/tests/ProjectDependency/main.cpp +++ b/tests/ProjectDependency/main.cpp @@ -115,6 +115,21 @@ int main(int argc, char** argv) { std::println(std::cerr, "FAIL: LoadProject threw: {}", e.what()); return 1; } + + // Host tooling gets none of the consumer's args, although a LocalProject + // spec defaults to them: the consumer's flags would split the tool's + // variant from every other consumer's, and its --target= would have the + // tool's project.cpp choose for the wrong triple. + try { + std::array flavored = { "--flavor=x" }; + Configuration cfg = LoadProject(app, flavored); + const bool found = !cfg.dependencies.empty(); + Check(found, "a consumer loaded with args still finds its pragma dependency"); + if (found) Check(cfg.dependencies[0]->projectArgs.empty(), std::format("a pragma dependency is loaded without the consumer's args (got {})", cfg.dependencies[0]->projectArgs)); + } catch (const std::exception& e) { + std::println(std::cerr, "FAIL: LoadProject with args threw: {}", e.what()); + return 1; + } Check(fs::exists(appSo), "project.so was produced"); if (!fs::exists(appSo)) return 1; const fs::file_time_type firstSo = fs::last_write_time(appSo); From 973c2708feab619c15e7b0559c3f3d6ebf3d40b6 Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 02:57:03 +0100 Subject: [PATCH 03/12] refactor: drop the depArgs copy from the self-host project.cpp Crafter.Math and Crafter.Asset now get this project's args through the GitProjectSpec default. Loading this file therefore needs a crafter-build that exports ProjectArgs: after pulling, run ./build.sh before the bootstrap binary loads it. Co-Authored-By: Claude Opus 5.5 --- project.cpp | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/project.cpp b/project.cpp index d3771f8..85b72f2 100644 --- a/project.cpp +++ b/project.cpp @@ -137,15 +137,8 @@ Remove it (do this before `crafter-build clean`, which deletes the repo the remo } extern "C" Configuration CrafterBuildProject(std::span args) { - std::vector 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, - }); + Configuration* math = GitProject({ .source = { "https://forgejo.catcrafts.net/Catcrafts/Crafter.Math.git" } }); + Configuration* asset = GitProject({ .source = { "https://forgejo.catcrafts.net/Catcrafts/Crafter.Asset.git" } }); static auto CrafterBuildLib = std::make_unique(); CrafterBuildLib->path = "./"; From 8fadbdae37bbc4c1538f4d8a85aecb6b5aef1bdf Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 02:58:41 +0100 Subject: [PATCH 04/12] refactor(lint): check this tree with the lite house rules Crafter.LintRules now has AddLiteRules: the house rules without the ones that only decide layout, whitespace and naming. This tree switches to it. The full set's naming rule now wants camelCase statics and constants, which this tree spells PascalCase throughout, so `lint` with it reported 49 findings on code that follows the documented convention; with the lite set `lint` and `format --check` are clean. AGENTS.md described the 17 rules as the enforced style and told contributors to let `format` restyle their code. It now says which 8 rules `lint` enforces, that `format` only rewrites string concatenation and builtin integer types, and lists layout and naming as conventions kept by hand. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 11 +++++++---- project.cpp | 12 ++++++++---- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 6bdde3b..ffd0057 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -95,14 +95,17 @@ Cross-target runs use `test --target=` with `--runner=local` or `--runne ## Code style -Style is enforced by the 17 rules in [Crafter.LintRules](https://forgejo.catcrafts.net/Catcrafts/Crafter.LintRules), which `project.cpp` pulls in through `#pragma crafter dependency` and applies with `crafter-build format` and `lint`. Most rules are transforms, so run `format` and let it restyle rather than hand-formatting. In short: +`project.cpp` pulls in [Crafter.LintRules](https://forgejo.catcrafts.net/Catcrafts/Crafter.LintRules) through `#pragma crafter dependency` and applies its lite set, `LintRules::AddLiteRules`: the 8 rules that ask for different code, without the ones that only decide layout, whitespace and naming. `lint` reports all 8; `format` applies the two transforms among them, `format-concat` and `fixed-width-types`, and leaves everything else as written. Enforced: - The first three lines of every source: `// SPDX-License-Identifier: LGPL-3.0-only`, `// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®`, blank. Examples use MIT. +- `enum class` only. `std::println` instead of iostream. `std::format` instead of string concatenation. `std::int32_t` and friends instead of `int` or `long` (exempt: `main`, `argc`/`argv`, `extern "C"` and foreign API signatures). No `char*` outside C interop. +- `const` on scalar locals that are never written; `constexpr` on constants with constant initialisers. + +Not checked, so match the surrounding code: + - Four-space indentation, no tabs, no trailing whitespace, final newline. - `PascalCase` for types, functions, statics and constants; `camelCase` for variables; a trailing `_` is allowed. -- `enum class` only. `std::println` instead of iostream. `std::format` instead of string concatenation. `std::int32_t` and friends instead of `int` or `long` (exempt: `main`, `argc`/`argv`, `extern "C"` and foreign API signatures). No `char*` outside C interop. -- One declaration per statement. K&R braces. `if (x) return;` on one line when it fits. The formatter joins wrapped statements that fit on one line, so do not hand-wrap short ones. `if (` and `for (` with a space; no space before a call's `(`. -- `const` on scalar locals that are never written; `constexpr` on constants with constant initialisers. +- One declaration per statement. K&R braces. `if (x) return;` on one line when it fits, and no hand-wrapping of a statement that fits on one line. `if (` and `for (` with a space; no space before a call's `(`. Suppress one finding with `// lint-disable-next-line ` or a whole file with `// lint-disable-file `. Both are rare in this tree and need a reason. diff --git a/project.cpp b/project.cpp index 85b72f2..4ea9679 100644 --- a/project.cpp +++ b/project.cpp @@ -288,10 +288,14 @@ extern "C" Configuration CrafterBuildProject(std::span a 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); + // Dogfood: the lite house rules, imported from their own repo through + // the pragma above. Lite is the house rules without the ones that only + // decide layout, whitespace and naming, which this tree keeps by hand: + // the full set's naming rule, for one, wants camelCase where this tree + // spells its statics and constants PascalCase. Report rules gate + // `crafter-build lint`; the two transforms also auto-fix under + // `crafter-build format`. + LintRules::AddLiteRules(cfg); // See the top of this file. cfg.scripts.push_back({"flatpak", BuildFlatpak}); From 5cf295e1d48c8963f03dc7bfa5d87f17277e8500 Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 02:59:13 +0100 Subject: [PATCH 05/12] docs: sibling projects forward the parent's args by default The sibling-project example dropped its `.args = depArgs`, which no longer has to be written, and says what a sibling receives instead: the args the project file was loaded with, or whatever `.args` is set to, with `{}` for nothing. It also says that releases up to 2.2.0 forward nothing without `.args`, which matters for a project.cpp that has to load on both. The pragma section says that a project file's own dependency is built for the host and gets none of the project's args, the one place the default does not apply. Co-Authored-By: Claude Opus 5.5 --- README.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 36445dc..89fc5de 100644 --- a/README.md +++ b/README.md @@ -69,12 +69,13 @@ Clones live at `~/.cache/crafter.build/external/-/`, keyed by `(url, ```cpp Configuration* math = GitProject({ .source = { .url = "https://forgejo.catcrafts.net/Catcrafts/Crafter.Math.git" }, // .branch or .commit to pin - .args = depArgs, // forwarded to its CrafterBuildProject }); -Configuration* sibling = LocalProject({ .projectFile = "../Crafter.Math/project.cpp", .args = depArgs }); +Configuration* sibling = LocalProject({ .projectFile = "../Crafter.Math/project.cpp" }); cfg.dependencies = { math }; ``` +The sibling's `CrafterBuildProject` gets the args this `project.cpp` was loaded with (`ProjectArgs()`), so `--target=`, `--march=`, `--debug` and the project's own flags reach every sibling down the chain. Set `.args` to send something else: `{}` for nothing, or a list built from the project's args, say one without a flag only this project reads (it would otherwise give the sibling a build directory of its own) or with an extra `--target=`. Releases up to 2.2.0 forward nothing when `.args` is left out. + Clones share the external cache and identical specs share one `Configuration`. An unpinned source is `git pull`ed on every invocation, set `.commit` for reproducible, offline-after-first-fetch builds. A project loaded this way runs its `CrafterBuildProject` as a dependency, and `IsTopLevelProject()` is `false` while it does (`true` in the project crafter-build was pointed at, and outside any project file). Wire test-only dependencies behind it: a library whose test links crafter-build itself would otherwise load crafter-build's `project.cpp` from inside crafter-build and recurse. @@ -94,6 +95,8 @@ import Crafter.LintRules; #pragma crafter dependency "" [branch "" | commit ""] [project ""] ``` +Such a dependency is built for the host, whatever the project targets, and its `project.cpp` gets none of the project's args. + ## Tests Tests live under `tests//`. The simplest case is a single C++ file: From 060ab4380fd18b1798244a8efe61a90082e2c7b9 Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 05:09:51 +0100 Subject: [PATCH 06/12] fix: give a project file its args only for the CrafterBuildProject call ProjectArgs() read args that LoadProject recorded when it pushed the frame, so they were there for everything that ran on that frame, not only for CrafterBuildProject. Two things went wrong with that. The pragma pre-pass runs on the frame too, so both of its specs needed a hand-written `.args = {}` to keep the consumer's args from reaching host tooling, and anything else built there would have needed one as well. And dlopen runs a project file's static initialisers only on the first load of that file: a later load gets the same mapping back. A spec made at namespace scope therefore kept the first load's args for every later load of the file, a silently wrong variant. The frame now gets the args just before CrafterBuildProject is called. The pre-pass and the static initialisers see none, on every load, so the two opt-outs go. The dependencies the pre-pass resolved move the other way, to just before dlopen: they are the same on every load, and ProjectDependency() called from a static initialiser used to find none and terminate the process. Co-Authored-By: Claude Opus 5.5 --- implementations/Crafter.Build-Platform.cpp | 44 ++++++++++++---------- interfaces/Crafter.Build-External.cppm | 25 +++++++----- 2 files changed, 40 insertions(+), 29 deletions(-) diff --git a/implementations/Crafter.Build-Platform.cpp b/implementations/Crafter.Build-Platform.cpp index 1d21c9c..f93e9f2 100644 --- a/implementations/Crafter.Build-Platform.cpp +++ b/implementations/Crafter.Build-Platform.cpp @@ -413,9 +413,10 @@ namespace { struct ProjectFileFrame { fs::path project; - // What LoadProject was given, for ProjectArgs(). A view is enough: - // the caller's storage outlives LoadProject, and the frame is popped - // before LoadProject returns. + // What LoadProject was given, for ProjectArgs(), and only once + // CrafterBuildProject is about to be called (see LoadProject). A view + // is enough: the caller's storage outlives LoadProject, and the frame + // is popped before LoadProject returns. std::span args; std::vector dependencies; }; @@ -430,10 +431,7 @@ namespace { // already on the stack is a cycle, which used to recurse forever. class ProjectFileGuard { public: - // The args are recorded with the frame rather than just before - // CrafterBuildProject runs, so a spec built while dlopen runs the - // project file's static initialisers sees them too. - ProjectFileGuard(const fs::path& absProject, std::span args) { + explicit ProjectFileGuard(const fs::path& absProject) { for (const ProjectFileFrame& frame : LoadingFrames) { if (frame.project != absProject) continue; std::string chain; @@ -441,7 +439,7 @@ namespace { throw std::runtime_error(std::format("circular project dependency: {}{}", chain, absProject.string())); } index_ = LoadingFrames.size(); - LoadingFrames.push_back({ absProject, args, {} }); + LoadingFrames.push_back({ absProject, {}, {} }); } ~ProjectFileGuard() { LoadingFrames.pop_back(); } ProjectFileGuard(const ProjectFileGuard&) = delete; @@ -503,16 +501,15 @@ namespace { std::set libs; for (const PragmaDependency& pragma : pragmas) { - // Host tooling is loaded with none of the consumer's args, so both - // specs pass `.args = {}` instead of defaulting to them. The tool - // is built for the host whatever the consumer targets: given the - // consumer's --target=, its project.cpp would pick sources and - // flags for the wrong triple before ForceHostTooling resets the - // fields, and the consumer's own flags would hash it apart from - // the build every other consumer of the tool shares. + // Neither spec sets args, and the tool still gets none of the + // consumer's: this pre-pass runs before LoadProject hands the + // frame its args, so ProjectArgs() is empty. Given the consumer's + // --target=, the tool's project.cpp would pick sources and flags + // for the wrong triple, and its flags would split the tool's + // variant from the one every other consumer shares. Configuration* cfg = nullptr; if (IsGitSource(pragma.source)) { - GitProjectSpec spec{ .source = { pragma.source, pragma.branch, pragma.commit }, .args = {} }; + GitProjectSpec spec{ .source = { pragma.source, pragma.branch, pragma.commit } }; if (!pragma.project.empty()) spec.projectFile = pragma.project; cfg = GitProject(spec); } else { @@ -526,7 +523,7 @@ namespace { PragmaError(absProject, pragma.line, "'project' only applies to a directory source"); } if (!fs::exists(local)) PragmaError(absProject, pragma.line, std::format("no such project file: {}", local.string())); - cfg = LocalProject({ .projectFile = local, .args = {} }); + cfg = LocalProject({ .projectFile = local }); } if (std::ranges::contains(out.configs, cfg)) continue; @@ -902,7 +899,7 @@ namespace { Configuration Crafter::LoadProject(const fs::path& projectFile, std::span args) { RequireToolchain(); fs::path absProject = fs::canonical(projectFile); - ProjectFileGuard guard(absProject, args); + ProjectFileGuard guard(absProject); fs::path buildDir = absProject.parent_path() / "build"; if (!fs::exists(buildDir)) { fs::create_directories(buildDir); @@ -974,6 +971,9 @@ Configuration Crafter::LoadProject(const fs::path& projectFile, std::span ProjectArgs(); // Specification for a sibling crafter-build project to fetch and depend on. From e6363b95fed613b57d3a0c30b0b99ba51271bfbd Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 05:10:02 +0100 Subject: [PATCH 07/12] test: specs and ProjectDependency() in a project file's static initialisers ProjectArgs gets a sibling that makes its own sibling's spec at namespace scope. Before the fix that spec took the args the file was first loaded with; now it takes none on every load. The checks go through one CheckLoaded helper, which prints what each sibling was given, so a failure says which args a wrong frame handed over. ProjectDependency loads a fixture whose static initialiser asks for its pragma dependency, in a child, because a throw there terminates the process: before the fix it found none. The check that the dependency gets none of the consumer's args moves into the first load, which now passes the app an arg it ignores; the separate load could not fail its own check, and its early return skipped every later one. Co-Authored-By: Claude Opus 5.5 --- tests/ProjectArgs/fixture/app/project.cpp | 8 +-- tests/ProjectArgs/fixture/static/project.cpp | 26 ++++++++++ tests/ProjectArgs/main.cpp | 49 ++++++++++++------- .../fixture/static-dep/project.cpp | 22 +++++++++ tests/ProjectDependency/main.cpp | 33 +++++++------ 5 files changed, 102 insertions(+), 36 deletions(-) create mode 100644 tests/ProjectArgs/fixture/static/project.cpp create mode 100644 tests/ProjectDependency/fixture/static-dep/project.cpp diff --git a/tests/ProjectArgs/fixture/app/project.cpp b/tests/ProjectArgs/fixture/app/project.cpp index 353c592..7b51816 100644 --- a/tests/ProjectArgs/fixture/app/project.cpp +++ b/tests/ProjectArgs/fixture/app/project.cpp @@ -6,12 +6,14 @@ import Crafter.Build; using namespace Crafter; // Loads the same sibling three ways: with its args left at their default, -// with nothing forwarded, and with a list of its own. The test reads what -// each copy received back out of cfg.dependencies. +// with nothing forwarded, and with a list of its own. Then a sibling that +// makes its own sibling's spec at namespace scope. The test reads what each +// copy received back out of cfg.dependencies. extern "C" Configuration CrafterBuildProject(std::span args) { Configuration* inherited = LocalProject({ .projectFile = "../lib/project.cpp" }); Configuration* none = LocalProject({ .projectFile = "../lib/project.cpp", .args = {} }); Configuration* replaced = LocalProject({ .projectFile = "../lib/project.cpp", .args = { "--only" } }); + Configuration* fromStatic = LocalProject({ .projectFile = "../static/project.cpp" }); Configuration cfg; cfg.path = "./"; @@ -19,7 +21,7 @@ extern "C" Configuration CrafterBuildProject(std::span a cfg.outputName = "app"; cfg.type = ConfigurationType::Executable; ApplyStandardArgs(cfg, args); - cfg.dependencies = { inherited, none, replaced }; + cfg.dependencies = { inherited, none, replaced, fromStatic }; // GitProjectSpec takes the same default. Checked on the spec itself, // since a GitProject would need a repository to clone. const GitProjectSpec git{ .source = { .url = "unused" } }; diff --git a/tests/ProjectArgs/fixture/static/project.cpp b/tests/ProjectArgs/fixture/static/project.cpp new file mode 100644 index 0000000..84f75bd --- /dev/null +++ b/tests/ProjectArgs/fixture/static/project.cpp @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Crafter.Build; +using namespace Crafter; + +// Makes its sibling's spec at namespace scope, so the spec's args default +// while LoadProject dlopens this file: before CrafterBuildProject is called, +// and on the first load of the file only. +namespace { + const LocalProjectSpec LeafSpec{ .projectFile = "../leaf/project.cpp" }; +} + +extern "C" Configuration CrafterBuildProject(std::span args) { + Configuration* leaf = LocalProject(LeafSpec); + + Configuration cfg; + cfg.path = "./"; + cfg.name = "static"; + cfg.outputName = "static"; + cfg.type = ConfigurationType::LibraryStatic; + ApplyStandardArgs(cfg, args); + cfg.dependencies = { leaf }; + return cfg; +} diff --git a/tests/ProjectArgs/main.cpp b/tests/ProjectArgs/main.cpp index 4b47938..6bf4005 100644 --- a/tests/ProjectArgs/main.cpp +++ b/tests/ProjectArgs/main.cpp @@ -15,7 +15,10 @@ using namespace Crafter; // release while the project built --debug. The fixture is a chain // app -> lib -> leaf of LocalProjects; app also loads lib with an empty and // with a replaced list, and checks the GitProjectSpec default itself, which -// a clone would need a repository for. +// a clone would need a repository for. A spec made at namespace scope gets +// no args: made while dlopen runs the file's static initialisers, which +// happens on its first load only, it would otherwise keep that load's args +// for every later one. namespace { std::int32_t Failures = 0; @@ -26,10 +29,21 @@ namespace { } } - // The single sibling lib and leaf declare, or nullptr. + // The single sibling lib, static and leaf declare, or nullptr. const Configuration* OnlyDependency(const Configuration& cfg) { return cfg.dependencies.size() == 1 ? cfg.dependencies[0] : nullptr; } + + // What a sibling was loaded with, as ApplyStandardArgs split it up: + // --debug into cfg.debug, the uninterpreted rest into cfg.projectArgs. + // Printed either way, so a failure says which args the sibling read. + void CheckLoaded(const Configuration* cfg, bool debug, const std::vector& rest, std::string_view what) { + if (!cfg) { + Check(false, std::format("{} (no such configuration)", what)); + return; + } + Check(cfg->debug == debug && cfg->projectArgs == rest, std::format("{} (debug {}, projectArgs {})", what, cfg->debug, cfg->projectArgs)); + } } int main() { @@ -60,24 +74,25 @@ int main() { try { Configuration cfg = LoadProject("project.cpp", args); Check(std::ranges::contains(cfg.compileFlags, "-DGIT_DEFAULT=1"), "a GitProjectSpec's args default to the project's own"); - Check(cfg.dependencies.size() == 3, std::format("the project declared its three siblings (got {})", cfg.dependencies.size())); - if (cfg.dependencies.size() == 3) { - const Configuration& inherited = *cfg.dependencies[0]; - const Configuration& none = *cfg.dependencies[1]; - const Configuration& replaced = *cfg.dependencies[2]; - Check(inherited.debug && inherited.projectArgs == flavor, std::format("a LocalProject without .args gets the project's args (debug {}, projectArgs {})", inherited.debug, inherited.projectArgs)); - Check(!none.debug && none.projectArgs.empty(), std::format("`.args = {{}}` forwards nothing (debug {}, projectArgs {})", none.debug, none.projectArgs)); - Check(!replaced.debug && replaced.projectArgs == only, std::format("an explicit list replaces the args rather than adding to them (debug {}, projectArgs {})", replaced.debug, replaced.projectArgs)); - Check(&inherited != &none && &inherited != &replaced && &none != &replaced, "each list loads its own configuration"); + Check(cfg.dependencies.size() == 4, std::format("the project declared its four siblings (got {})", cfg.dependencies.size())); + if (cfg.dependencies.size() == 4) { + const Configuration* inherited = cfg.dependencies[0]; + const Configuration* none = cfg.dependencies[1]; + const Configuration* replaced = cfg.dependencies[2]; + const Configuration* fromStatic = cfg.dependencies[3]; + CheckLoaded(inherited, true, flavor, "a LocalProject without .args gets the project's args"); + CheckLoaded(none, false, {}, "`.args = {}` forwards nothing"); + CheckLoaded(replaced, false, only, "an explicit list replaces the args rather than adding to them"); + Check(inherited != none && inherited != replaced && none != replaced, "each list loads its own configuration"); // One sibling further down, the same default passes on what the // middle project was given, not what the top one was. - const Configuration* inheritedLeaf = OnlyDependency(inherited); - Check(inheritedLeaf && inheritedLeaf->debug && inheritedLeaf->projectArgs == flavor, "the project's args reach its sibling's sibling"); - const Configuration* noneLeaf = OnlyDependency(none); - Check(noneLeaf && !noneLeaf->debug && noneLeaf->projectArgs.empty(), "a sibling loaded with nothing passes nothing on"); - const Configuration* replacedLeaf = OnlyDependency(replaced); - Check(replacedLeaf && !replacedLeaf->debug && replacedLeaf->projectArgs == only, "a sibling passes on the list it was given"); + CheckLoaded(OnlyDependency(*inherited), true, flavor, "the project's args reach its sibling's sibling"); + CheckLoaded(OnlyDependency(*none), false, {}, "a sibling loaded with nothing passes nothing on"); + CheckLoaded(OnlyDependency(*replaced), false, only, "a sibling passes on the list it was given"); + + CheckLoaded(fromStatic, true, flavor, "the sibling with a namespace-scope spec is itself loaded with the args"); + CheckLoaded(OnlyDependency(*fromStatic), false, {}, "a spec made at namespace scope forwards nothing"); } } catch (const std::exception& e) { fs::current_path(cwd); diff --git a/tests/ProjectDependency/fixture/static-dep/project.cpp b/tests/ProjectDependency/fixture/static-dep/project.cpp new file mode 100644 index 0000000..2090db5 --- /dev/null +++ b/tests/ProjectDependency/fixture/static-dep/project.cpp @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Crafter.Build; +#pragma crafter dependency "../greeter" +using namespace Crafter; + +// Asks for its dependency at namespace scope, so the call runs while +// LoadProject dlopens this file, before CrafterBuildProject is called. +namespace { + Configuration* const Greeter = ProjectDependency("greeter"); +} + +extern "C" Configuration CrafterBuildProject(std::span) { + Configuration cfg; + cfg.path = "./"; + cfg.name = std::format("static {}", Greeter->name); + cfg.outputName = "static-dep"; + cfg.type = ConfigurationType::Executable; + return cfg; +} diff --git a/tests/ProjectDependency/main.cpp b/tests/ProjectDependency/main.cpp index de01130..595d17c 100644 --- a/tests/ProjectDependency/main.cpp +++ b/tests/ProjectDependency/main.cpp @@ -90,14 +90,19 @@ int main(int argc, char** argv) { const fs::path app = scratch / "app" / "project.cpp"; const fs::path appSo = scratch / "app" / "build" / "project.so"; - std::array noArgs = {}; Check(IsTopLevelProject(), "outside any project file counts as top level"); // The dependency is fetched, built and linked before project.cpp runs, - // and ProjectDependency() hands it back by either name. + // and ProjectDependency() hands it back by either name. The app ignores + // the arg it is loaded with, and the dependency must not get it: host + // tooling gets none of the consumer's args, although a LocalProject spec + // defaults to them. The consumer's flags would split the tool's variant + // from every other consumer's, and its --target= would have the tool's + // project.cpp choose for the wrong triple. try { - Configuration cfg = LoadProject(app, noArgs); + std::array flavored = { "--flavor=x" }; + Configuration cfg = LoadProject(app, flavored); Check(cfg.name == "hello from greeter", std::format("project.cpp imported and called the dependency's module (got '{}')", cfg.name)); Check(std::ranges::contains(cfg.compileFlags, "-DTOP_LEVEL=1"), "the project LoadProject was pointed at sees itself as top level"); Check(cfg.dependencies.size() == 2, "ProjectDependency resolved by module name and by configuration name"); @@ -109,6 +114,7 @@ int main(int argc, char** argv) { Check(dep.march == "native", "the environment's march was overridden for host tooling"); Check(std::ranges::contains(dep.compileFlags, "-fPIC"), "the dependency archive was built position-independent"); Check(std::ranges::contains(dep.compileFlags, "-DTOP_LEVEL=0"), "a dependency's project file does not see itself as top level"); + Check(dep.projectArgs.empty(), std::format("the dependency got none of the consumer's args (got {})", dep.projectArgs)); Check(fs::exists(ExpectedOutput(dep)), "the dependency archive exists"); } } catch (const std::exception& e) { @@ -116,20 +122,15 @@ int main(int argc, char** argv) { return 1; } - // Host tooling gets none of the consumer's args, although a LocalProject - // spec defaults to them: the consumer's flags would split the tool's - // variant from every other consumer's, and its --target= would have the - // tool's project.cpp choose for the wrong triple. - try { - std::array flavored = { "--flavor=x" }; - Configuration cfg = LoadProject(app, flavored); - const bool found = !cfg.dependencies.empty(); - Check(found, "a consumer loaded with args still finds its pragma dependency"); - if (found) Check(cfg.dependencies[0]->projectArgs.empty(), std::format("a pragma dependency is loaded without the consumer's args (got {})", cfg.dependencies[0]->projectArgs)); - } catch (const std::exception& e) { - std::println(std::cerr, "FAIL: LoadProject with args threw: {}", e.what()); - return 1; + // A static initialiser of the project file runs while LoadProject + // dlopens it, before CrafterBuildProject is called, and can already ask + // for a dependency. In a child, because a static initialiser that + // throws terminates the process. + { + const std::string loaded = LoadInChild(scratch / "static-dep" / "project.cpp"); + Check(loaded == "static greeter", std::format("ProjectDependency() works in a static initialiser (got '{}')", loaded)); } + Check(fs::exists(appSo), "project.so was produced"); if (!fs::exists(appSo)) return 1; const fs::file_time_type firstSo = fs::last_write_time(appSo); From e420c9f95861de563ef4cd263527f4e0d5f90603 Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 05:10:21 +0100 Subject: [PATCH 08/12] fix: keep host tooling out of the project cache the target uses ForceHostTooling rewrites a `#pragma crafter dependency` and everything it loads in place: host target, march native, release, -fPIC. Those are entries of the project cache like any other, keyed by project file and args alone. A project that loaded the same sibling as its tool, with the same args, got the rewritten entry back. That happens whenever the project gets no args, since host tooling gets none either: a consumer built for x86-64-v2 then imported a sibling's BMI compiled with -march=native, and clang refused it. Any arg on the command line split the keys and hid it. A thread-local count of pragma loads now marks the tool's load and every load inside it, its project file's siblings included, and GitProject and LocalProject put that mark in the key. The clone stays shared; only the Configuration is separate, as for two arg lists. A module-internal function rather than a spec field, because the siblings of a tool are loaded by the tool's own project.cpp, which cannot know it is host tooling. Co-Authored-By: Claude Opus 5.5 --- implementations/Crafter.Build-External.cpp | 7 +-- implementations/Crafter.Build-Platform.cpp | 58 ++++++++++++++++------ interfaces/Crafter.Build-Platform.cppm | 6 +++ 3 files changed, 52 insertions(+), 19 deletions(-) diff --git a/implementations/Crafter.Build-External.cpp b/implementations/Crafter.Build-External.cpp index 6e12988..ff0c766 100644 --- a/implementations/Crafter.Build-External.cpp +++ b/implementations/Crafter.Build-External.cpp @@ -360,11 +360,12 @@ Configuration* Crafter::GitProject(const GitProjectSpec& spec) { // source revision (forwarded args don't change what gets cloned, just // how the dep's project.cpp interprets them at runtime), while the // in-memory Configuration is keyed by the full spec so each (args) - // permutation gets its own Configuration object. + // permutation gets its own Configuration object, and host tooling one + // apart from the target's even for the same args. std::string srcKey = std::format("git|{}|{}|{}|{}", spec.source.url, spec.source.branch, spec.source.commit, spec.projectFile.string()); std::string srcHash = std::format("{:016x}", std::hash{}(srcKey)); - std::string fullKey = srcKey; + std::string fullKey = std::format("{}{}", LoadingHostTooling() ? "host|" : "", srcKey); for (const std::string& a : spec.args) { fullKey += '|'; fullKey += a; @@ -449,7 +450,7 @@ Configuration* Crafter::LocalProject(const LocalProjectSpec& spec) { } fs::path canonical = fs::canonical(projectPath); - std::string fullKey = std::format("local|{}", canonical.string()); + std::string fullKey = std::format("{}local|{}", LoadingHostTooling() ? "host|" : "", canonical.string()); for (const std::string& a : spec.args) { fullKey += '|'; fullKey += a; diff --git a/implementations/Crafter.Build-Platform.cpp b/implementations/Crafter.Build-Platform.cpp index f93e9f2..b727cbb 100644 --- a/implementations/Crafter.Build-Platform.cpp +++ b/implementations/Crafter.Build-Platform.cpp @@ -451,6 +451,21 @@ namespace { std::size_t index_ = 0; }; + // How many `#pragma crafter dependency` loads this thread is inside. The + // tool's project file runs within its load, and so does every sibling it + // loads in turn, which is what LoadingHostTooling() reports to GitProject + // and LocalProject. Per thread like LoadingFrames: a sibling loaded on a + // thread of the tool's own goes uncounted, as it gets no ProjectArgs(). + thread_local std::int32_t HostToolingLoads = 0; + + class HostToolingScope { + public: + HostToolingScope() { ++HostToolingLoads; } + ~HostToolingScope() { --HostToolingLoads; } + HostToolingScope(const HostToolingScope&) = delete; + HostToolingScope& operator=(const HostToolingScope&) = delete; + }; + // A pre-dependency is host tooling: project.so is loaded into the running // crafter-build, so the dependency is built for the host and against the // same PCM cache LoadProject populates — the hostConfig LoadProject itself @@ -506,24 +521,31 @@ namespace { // frame its args, so ProjectArgs() is empty. Given the consumer's // --target=, the tool's project.cpp would pick sources and flags // for the wrong triple, and its flags would split the tool's - // variant from the one every other consumer shares. + // variant from the one every other consumer shares. The scope + // keeps the tool and everything it loads in a project cache of + // their own: ForceHostTooling rewrites them in place, and a + // consumer loading the same sibling for itself got that host + // build back whenever the two cache keys matched. Configuration* cfg = nullptr; - if (IsGitSource(pragma.source)) { - GitProjectSpec spec{ .source = { pragma.source, pragma.branch, pragma.commit } }; - if (!pragma.project.empty()) spec.projectFile = pragma.project; - cfg = GitProject(spec); - } else { - if (!pragma.branch.empty() || !pragma.commit.empty()) PragmaError(absProject, pragma.line, "'branch' and 'commit' only apply to a git source"); - // Relative to the project file, not the cwd: LoadProject runs - // from wherever the consumer was invoked. - fs::path local = (absProject.parent_path() / pragma.source).lexically_normal(); - if (fs::is_directory(local)) { - local /= pragma.project.empty() ? fs::path("project.cpp") : fs::path(pragma.project); - } else if (!pragma.project.empty()) { - PragmaError(absProject, pragma.line, "'project' only applies to a directory source"); + { + HostToolingScope hostTooling; + if (IsGitSource(pragma.source)) { + GitProjectSpec spec{ .source = { pragma.source, pragma.branch, pragma.commit } }; + if (!pragma.project.empty()) spec.projectFile = pragma.project; + cfg = GitProject(spec); + } else { + if (!pragma.branch.empty() || !pragma.commit.empty()) PragmaError(absProject, pragma.line, "'branch' and 'commit' only apply to a git source"); + // Relative to the project file, not the cwd: LoadProject runs + // from wherever the consumer was invoked. + fs::path local = (absProject.parent_path() / pragma.source).lexically_normal(); + if (fs::is_directory(local)) { + local /= pragma.project.empty() ? fs::path("project.cpp") : fs::path(pragma.project); + } else if (!pragma.project.empty()) { + PragmaError(absProject, pragma.line, "'project' only applies to a directory source"); + } + if (!fs::exists(local)) PragmaError(absProject, pragma.line, std::format("no such project file: {}", local.string())); + cfg = LocalProject({ .projectFile = local }); } - if (!fs::exists(local)) PragmaError(absProject, pragma.line, std::format("no such project file: {}", local.string())); - cfg = LocalProject({ .projectFile = local }); } if (std::ranges::contains(out.configs, cfg)) continue; @@ -597,6 +619,10 @@ std::vector Crafter::ProjectArgs() { return std::vector(args.begin(), args.end()); } +bool Crafter::LoadingHostTooling() { + return HostToolingLoads > 0; +} + namespace { // The one reading of a wait status (pclose, system) for every helper // that runs a command: a signal death is reported the way a shell diff --git a/interfaces/Crafter.Build-Platform.cppm b/interfaces/Crafter.Build-Platform.cppm index 2601275..eb9110c 100644 --- a/interfaces/Crafter.Build-Platform.cppm +++ b/interfaces/Crafter.Build-Platform.cppm @@ -75,6 +75,12 @@ namespace Crafter { // that library as a dependency, the test's GitProject loads crafter-build's // project file in turn and the two recurse until the cycle guard throws. export bool IsTopLevelProject(); + // True while this thread loads a `#pragma crafter dependency`: the tool's + // project file and every sibling it loads in turn. GitProject and + // LocalProject key the project cache on it, so host tooling, which + // ForceHostTooling rewrites in place, never shares a Configuration with a + // load for the target. + bool LoadingHostTooling(); // Resolves the directory holding distributed runtime assets (Crafter.Build // module sources, wasi-runtime/, etc). Honors CRAFTER_BUILD_HOME; otherwise // derives /share/crafter-build from the running executable's path. From 95896a7ddd94266048783a4816f1575dad9a7a94 Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 05:10:28 +0100 Subject: [PATCH 09/12] test: a project and its pragma dependency load a shared sibling apart The fixture app has `#pragma crafter dependency "../tool"` and loads ../shared for itself, which the tool loads too; the app is loaded with no args, the case where the two cache keys used to match. With CRAFTER_BUILD_MARCH=x86-64-v2, the app's copy of shared has to keep that march and no -fPIC, and the tool's copy has to be host tooling. Before the fix the app got the tool's copy back: one Configuration, with march native and -fPIC. Co-Authored-By: Claude Opus 5.5 --- project.cpp | 2 + .../fixture/app/project.cpp | 22 ++++++ .../fixture/shared/interfaces/Shared.cppm | 5 ++ .../fixture/shared/project.cpp | 23 ++++++ .../fixture/tool/interfaces/Tool.cppm | 6 ++ .../fixture/tool/project.cpp | 24 ++++++ tests/HostToolingSibling/main.cpp | 79 +++++++++++++++++++ 7 files changed, 161 insertions(+) create mode 100644 tests/HostToolingSibling/fixture/app/project.cpp create mode 100644 tests/HostToolingSibling/fixture/shared/interfaces/Shared.cppm create mode 100644 tests/HostToolingSibling/fixture/shared/project.cpp create mode 100644 tests/HostToolingSibling/fixture/tool/interfaces/Tool.cppm create mode 100644 tests/HostToolingSibling/fixture/tool/project.cpp create mode 100644 tests/HostToolingSibling/main.cpp diff --git a/project.cpp b/project.cpp index 4ea9679..bfd3e9b 100644 --- a/project.cpp +++ b/project.cpp @@ -282,6 +282,8 @@ extern "C" Configuration CrafterBuildProject(std::span a .LinkFlag("-Wl,--export-dynamic").LinkFlag("-ldl"); cfg.AddTest("ProjectArgs").Dependencies({ CrafterBuildLib.get() }) .LinkFlag("-Wl,--export-dynamic").LinkFlag("-ldl"); + cfg.AddTest("HostToolingSibling").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() }); diff --git a/tests/HostToolingSibling/fixture/app/project.cpp b/tests/HostToolingSibling/fixture/app/project.cpp new file mode 100644 index 0000000..d9f107a --- /dev/null +++ b/tests/HostToolingSibling/fixture/app/project.cpp @@ -0,0 +1,22 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Crafter.Build; +#pragma crafter dependency "../tool" +using namespace Crafter; + +// Loads for itself the sibling its tool loads, by the same path and, when +// the app gets no args, with the same args. +extern "C" Configuration CrafterBuildProject(std::span args) { + Configuration* shared = LocalProject({ .projectFile = "../shared/project.cpp" }); + + Configuration cfg; + cfg.path = "./"; + cfg.name = "app"; + cfg.outputName = "app"; + cfg.type = ConfigurationType::Executable; + ApplyStandardArgs(cfg, args); + cfg.dependencies = { shared, ProjectDependency("tool") }; + return cfg; +} diff --git a/tests/HostToolingSibling/fixture/shared/interfaces/Shared.cppm b/tests/HostToolingSibling/fixture/shared/interfaces/Shared.cppm new file mode 100644 index 0000000..af40390 --- /dev/null +++ b/tests/HostToolingSibling/fixture/shared/interfaces/Shared.cppm @@ -0,0 +1,5 @@ +export module Shared; +import std; +export std::int32_t SharedValue() { + return 7; +} diff --git a/tests/HostToolingSibling/fixture/shared/project.cpp b/tests/HostToolingSibling/fixture/shared/project.cpp new file mode 100644 index 0000000..3cd5bdc --- /dev/null +++ b/tests/HostToolingSibling/fixture/shared/project.cpp @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Crafter.Build; +namespace fs = std::filesystem; +using namespace Crafter; + +// The sibling both the tool and the app load. ApplyStandardArgs on purpose: +// it reads CRAFTER_BUILD_MARCH from the environment, which is how the test +// tells the app's copy from the one built as host tooling. +extern "C" Configuration CrafterBuildProject(std::span args) { + Configuration cfg; + cfg.path = "./"; + cfg.name = "shared"; + cfg.outputName = "shared"; + cfg.type = ConfigurationType::LibraryStatic; + ApplyStandardArgs(cfg, args); + std::array ifaces = { "interfaces/Shared" }; + std::array impls = {}; + cfg.GetInterfacesAndImplementations(ifaces, impls); + return cfg; +} diff --git a/tests/HostToolingSibling/fixture/tool/interfaces/Tool.cppm b/tests/HostToolingSibling/fixture/tool/interfaces/Tool.cppm new file mode 100644 index 0000000..c6d5490 --- /dev/null +++ b/tests/HostToolingSibling/fixture/tool/interfaces/Tool.cppm @@ -0,0 +1,6 @@ +export module Tool; +import std; +import Shared; +export std::int32_t ToolValue() { + return SharedValue(); +} diff --git a/tests/HostToolingSibling/fixture/tool/project.cpp b/tests/HostToolingSibling/fixture/tool/project.cpp new file mode 100644 index 0000000..51ad781 --- /dev/null +++ b/tests/HostToolingSibling/fixture/tool/project.cpp @@ -0,0 +1,24 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Crafter.Build; +namespace fs = std::filesystem; +using namespace Crafter; + +// The app's `#pragma crafter dependency`, with a sibling of its own. +extern "C" Configuration CrafterBuildProject(std::span args) { + Configuration* shared = LocalProject({ .projectFile = "../shared/project.cpp" }); + + Configuration cfg; + cfg.path = "./"; + cfg.name = "tool"; + cfg.outputName = "tool"; + cfg.type = ConfigurationType::LibraryStatic; + ApplyStandardArgs(cfg, args); + cfg.dependencies = { shared }; + std::array ifaces = { "interfaces/Tool" }; + std::array impls = {}; + cfg.GetInterfacesAndImplementations(ifaces, impls); + return cfg; +} diff --git a/tests/HostToolingSibling/main.cpp b/tests/HostToolingSibling/main.cpp new file mode 100644 index 0000000..f6ad160 --- /dev/null +++ b/tests/HostToolingSibling/main.cpp @@ -0,0 +1,79 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +#include +import std; +import Crafter.Build; +namespace fs = std::filesystem; +using namespace Crafter; + +// A sibling that a project and its `#pragma crafter dependency` both load +// is two configurations: the tool's copy is host tooling, built for the +// host and position-independent, and the project's is built the way the +// project builds. ForceHostTooling rewrites the tool's graph in place, and +// the project cache used to hand the project that same rewritten +// Configuration whenever the two loads had the same key, as they do when +// the project gets no args. The project then built against a sibling +// compiled with -march=native while itself building for x86-64-v2, and +// clang refused the sibling's BMI. +namespace { + std::int32_t Failures = 0; + + void Check(bool cond, std::string_view msg) { + if (!cond) { + std::println(std::cerr, "FAIL: {}", msg); + ++Failures; + } + } +} + +int main() { + const fs::path installedHome = GetCrafterBuildHome(); + if (!fs::exists(installedHome / "Crafter.Build.cppm")) { + std::println(std::cerr, "SKIP: no module sources at {}", installedHome.string()); + return 77; + } + + // Staged because LoadProject drops a build/ tree next to every project + // file it compiles, and the pre-pass builds the tool and its sibling. + const fs::path fixture = fs::current_path() / "tests" / "HostToolingSibling" / "fixture"; + const fs::path scratch = fs::temp_directory_path() / "crafter-build-host-tooling-sibling"; + std::error_code ec; + fs::remove_all(scratch, ec); + fs::create_directories(scratch); + fs::copy(fixture, scratch, fs::copy_options::recursive); + + // The march the project builds for. Host tooling overrides it to + // native, so a sibling that comes back with native was rewritten. + setenv("CRAFTER_BUILD_MARCH", "x86-64-v2", 1); + + // From the app's own directory, as crafter-build runs it: the fixture's + // LocalProject paths are relative to the working directory. + const fs::path cwd = fs::current_path(); + fs::current_path(scratch / "app"); + std::array noArgs = {}; + try { + Configuration cfg = LoadProject("project.cpp", noArgs); + Check(cfg.dependencies.size() == 2, std::format("the app declared its sibling and its tool (got {})", cfg.dependencies.size())); + if (cfg.dependencies.size() == 2) { + const Configuration* shared = cfg.dependencies[0]; + const Configuration* tool = cfg.dependencies[1]; + const Configuration* toolShared = tool->dependencies.size() == 1 ? tool->dependencies[0] : nullptr; + Check(toolShared != nullptr, "the tool declared its sibling"); + Check(shared != toolShared, "the app's sibling is not the tool's copy of it"); + Check(shared->march == "x86-64-v2", std::format("the app's sibling keeps the app's march (got {})", shared->march)); + Check(!std::ranges::contains(shared->compileFlags, "-fPIC"), "the app's sibling is not built as host tooling"); + if (toolShared) { + Check(toolShared->march == "native", std::format("the tool's copy is built for the host (got {})", toolShared->march)); + Check(std::ranges::contains(toolShared->compileFlags, "-fPIC"), "the tool's copy is position-independent"); + } + } + } catch (const std::exception& e) { + fs::current_path(cwd); + std::println(std::cerr, "FAIL: LoadProject threw: {}", e.what()); + return 1; + } + fs::current_path(cwd); + + return Failures > 0 ? 1 : 0; +} From 368fd2c527177d019fd81f2e330472c7203c85b2 Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 05:10:38 +0100 Subject: [PATCH 10/12] fix(cli): end the options at `--` instead of forwarding it The help has advertised `[options] [-- project-args...]`, but Run never looked for `--`. It fell through to projectArgs as a word of its own, and the words after it were still read as this tool's options and verbs: `crafter-build -- -v` turned verbose output on. In projectArgs `--` changed the project's variant hash, and now that siblings inherit the args, the hash of every sibling down the chain, each building into directories of its own that the project's clean never removes. `--` now ends this tool's options and goes nowhere itself. Every later word is an operand of the verb, as POSIX has it: a project arg for a build, a glob for test, lint and format, the script's name and then its args for run. A glob rather than a project arg after `test` because `crafter-build test -- 'House*'` is how such a filter gets typed; a project arg goes before the `--`. Co-Authored-By: Claude Opus 5.5 --- implementations/Crafter.Build-Clang.cpp | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/implementations/Crafter.Build-Clang.cpp b/implementations/Crafter.Build-Clang.cpp index 550023e..f93451a 100644 --- a/implementations/Crafter.Build-Clang.cpp +++ b/implementations/Crafter.Build-Clang.cpp @@ -1651,6 +1651,10 @@ Build options: -v, --verbose Verbose progress output. -q, --quiet Suppress progress output. --project= Path to the project file (default: ./project.cpp). + -- Ends this tool's options. Every later word is a + project arg, even one that looks like an option or + a verb; after test, lint or format, a glob; after + run, the script's name and then its args. Test options (after the `test` subcommand): --list Enumerate matching tests without running them. @@ -1762,6 +1766,9 @@ std::int32_t Crafter::Run(std::int32_t argc, char** argv) { RunLintOptions lintOpts; RunScriptOptions scriptOpts; Progress::Verbosity verbosity = Progress::Verbosity::Default; + // Set by `--`: every later word is an operand of the verb, never an + // option or a verb of this tool. + bool operandsOnly = false; for (std::int32_t i = 1; i < argc; ++i) { std::string_view arg = argv[i]; @@ -1773,11 +1780,25 @@ std::int32_t Crafter::Run(std::int32_t argc, char** argv) { // variant hash and so the directory the project builds into. if (scriptOpts.named) { scriptOpts.args.emplace_back(arg); - } else if (runScript && !arg.starts_with("-")) { + } else if (runScript && (operandsOnly || !arg.starts_with("-"))) { // The first word after `run`, even one that is a verb // elsewhere. Options before it keep their usual meaning. scriptOpts.name = arg; scriptOpts.named = true; + } else if (operandsOnly) { + if (runTests) { + testOpts.globs.emplace_back(arg); + } else if (runLint || runFormat) { + lintOpts.globs.emplace_back(arg); + } else { + projectArgs.push_back(arg); + } + } else if (arg == "--") { + // Ends this tool's options and is never forwarded itself. It + // used to land in projectArgs as a word of its own, giving the + // project a variant hash of its own, and every sibling project + // that inherits the args one as well. + operandsOnly = true; } else if (arg == "--version") { // Answered here, before the project file is looked for, so // it works in any directory and is never forwarded to From 70b68b98a5b1e584e50c29687ca5e3c4b47d8bde Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 05:10:38 +0100 Subject: [PATCH 11/12] test: `--` reaches neither the project args nor the script `run -- record -- a` has to run the record script with the args `--` and `a`: the first `--` ends the options, the second comes after the script's name and is the script's. The project args keep only what stood before `run`. And `run -- -x` has to look for a script called -x, since after `--` an option-like word is an operand. Before the fix the first `--` showed up in the project args, and `-x` joined it there while the bare `run` listed the scripts and succeeded. Co-Authored-By: Claude Opus 5.5 --- tests/Script/main.cpp | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/tests/Script/main.cpp b/tests/Script/main.cpp index 8e200a8..472682d 100644 --- a/tests/Script/main.cpp +++ b/tests/Script/main.cpp @@ -218,6 +218,29 @@ int main() { Check(fs::exists(binSentinel) && fs::exists(buildSentinel), "`clean` as a script argument deleted nothing"); } + // `--` ends this tool's options and goes nowhere itself. In the + // project's args it gave the project a variant of its own, and every + // sibling that inherits the args one too. The word after it is an + // operand even when it looks like an option, here the script's name; + // after the name, a `--` is the script's like any other word. + { + fs::remove(scratch / "record.txt"); + const std::int32_t code = RunWith({"crafter-build", project, "--flavour=x", "run", "--", "record", "--", "a"}); + Check(code == 42, std::format("the script after `--` ran (got {})", code)); + const std::vector expected = { + "arg:--", "arg:a", + "projectArg:--flavour=x", + "debug:false", + "project:script-fixture", + }; + const std::vector record = ReadLines(scratch / "record.txt"); + Check(record == expected, "`--` reached neither the project args nor the script"); + if (record != expected) { + for (const std::string& line : record) std::println(std::cerr, " recorded: {}", line); + } + Check(RunWith({"crafter-build", project, "run", "--", "-x"}) == 1, "after `--` a word that looks like an option names the script"); + } + // The first word after `run` is the name even when it is a verb. { fs::remove(scratch / "record.txt"); From 84d9d666490e2d7044f470b0e50f84171eb9b427 Mon Sep 17 00:00:00 2001 From: Jorijn van der Graaf Date: Sat, 31 Oct 2026 05:10:48 +0100 Subject: [PATCH 12/12] docs: correct what the sibling-args docs promise The README suggested giving one sibling a list without a flag only the project reads, so that the sibling would not get a build directory of its own. When another path loads the same sibling with the full list, that filter is what gives it the second directory: two builds of one project, both in the program (#41). It now says to build such a list once and give it to every sibling. It also says the default is read when the spec is made, so a spec made at namespace scope, on another thread or in a script forwards nothing, and that cfg.projectArgs, the part ApplyStandardArgs did not interpret, is no substitute: it drops the target and the build type. The comments on ProjectArgs() and on Configuration::projectArgs say the same. The spec comment named --local as a flag the default carries down a chain of siblings. Through a GitProject hop it breaks: the clone has no checkouts beside it. The GitProject comment said the clone is keyed by the args; only the Configuration is, and every arg list builds in the one clone. AGENTS.md now notes that a stale harness gives no symptom for a changed default member initialiser: project.cpp silently gets the old default. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 2 +- README.md | 4 +++- interfaces/Crafter.Build-Clang.cppm | 4 +++- interfaces/Crafter.Build-External.cppm | 23 ++++++++++++++--------- 4 files changed, 21 insertions(+), 12 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index ffd0057..d5227e8 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -45,7 +45,7 @@ Prerequisites on Linux: `clang` (with `libclang`, which the AST lint rules load Three things to know about this loop: - `bin/crafter-build` is the bootstrap binary and the harness for every command below. The self-host build writes to `bin/crafter.build-exe-/crafter-build` and does not replace it. -- Changes under `implementations/` are picked up by the self-host build and by the tests, which link the local library. Changes under `interfaces/` are not: the harness compiles against the copies in `share/crafter-build/` and the PCM cache built from them, so a new or changed declaration is invisible until you run `./build.sh` again. The symptom is `use of undeclared identifier` for the symbol you just added. +- Changes under `implementations/` are picked up by the self-host build and by the tests, which link the local library. Changes under `interfaces/` are not: the harness compiles against the copies in `share/crafter-build/` and the PCM cache built from them, so a new or changed declaration is invisible until you run `./build.sh` again. The symptom is `use of undeclared identifier` for the symbol you just added. A changed default member initialiser has no symptom at all: `project.cpp` compiles against the old one and quietly gets the old default, as `project.cpp`'s sibling loads do with a harness that predates `GitProjectSpec::args = ProjectArgs()`. - A new exported symbol that a `project.cpp` reaches on its default path also needs `./build.sh`: the old binary does not export it, and `LoadProject` fails with an undefined symbol. `./build.sh` clones and builds glslang on first run and takes several minutes; later runs are faster. `./bin/crafter-build clean` deletes `bin/` and `build/` without loading `project.cpp`. That takes `bin/crafter-build` itself with it, and `build/flatpak`, the state of the local Flatpak build (see "CI and publishing"): about 2 GB, and the next `run flatpak` rebuilds LLVM. Set `CRAFTER_BUILD_HOME` only when running a binary from outside this tree; `CRAFTER_BUILD_MARCH` and `CRAFTER_BUILD_MTUNE` default to `native`. diff --git a/README.md b/README.md index 89fc5de..2620f3f 100644 --- a/README.md +++ b/README.md @@ -74,7 +74,9 @@ Configuration* sibling = LocalProject({ .projectFile = "../Crafter.Math/project. cfg.dependencies = { math }; ``` -The sibling's `CrafterBuildProject` gets the args this `project.cpp` was loaded with (`ProjectArgs()`), so `--target=`, `--march=`, `--debug` and the project's own flags reach every sibling down the chain. Set `.args` to send something else: `{}` for nothing, or a list built from the project's args, say one without a flag only this project reads (it would otherwise give the sibling a build directory of its own) or with an extra `--target=`. Releases up to 2.2.0 forward nothing when `.args` is left out. +The sibling's `CrafterBuildProject` gets the args this `project.cpp` was loaded with (`ProjectArgs()`), so `--target=`, `--march=`, `--debug` and the project's own flags reach every sibling down the chain. That is all of them: `cfg.projectArgs` holds only what `ApplyStandardArgs` did not interpret, and passing it on would drop the target and the build type. Set `.args` to send something else: `{}` for nothing, or a list built from the project's args, such as one without a flag only this project reads. Build such a list once and give it to every sibling. A project that two paths load with different lists is built twice, and the program ends up with both builds. Releases up to 2.2.0 forward nothing when `.args` is left out. + +The default is read when the spec is made, so make it inside `CrafterBuildProject`, on the thread that calls it. A spec made at namespace scope, on a thread of your own or in a script forwards nothing. Clones share the external cache and identical specs share one `Configuration`. An unpinned source is `git pull`ed on every invocation, set `.commit` for reproducible, offline-after-first-fetch builds. diff --git a/interfaces/Crafter.Build-Clang.cppm b/interfaces/Crafter.Build-Clang.cppm index 12be520..07a787a 100644 --- a/interfaces/Crafter.Build-Clang.cppm +++ b/interfaces/Crafter.Build-Clang.cppm @@ -483,7 +483,9 @@ export namespace Crafter { // cfg.files, say), and without it both flag settings share one bin dir // and interleave their outputs there. Populated by ApplyStandardArgs; // the args it does recognise are excluded, since their effect already - // shows up in target/march/mtune/debug/sysroot/type. + // shows up in target/march/mtune/debug/sysroot/type. For the same + // reason this is not what to hand a sibling project: ProjectArgs() is + // every arg, the recognised ones included. std::vector projectArgs; std::vector tests; // Lint rules for `crafter-build lint`. Populate via AddLintRule. diff --git a/interfaces/Crafter.Build-External.cppm b/interfaces/Crafter.Build-External.cppm index 317879c..23ebe6e 100644 --- a/interfaces/Crafter.Build-External.cppm +++ b/interfaces/Crafter.Build-External.cppm @@ -93,21 +93,26 @@ export namespace Crafter { // remote's default branch HEAD (sloppy but convenient), set branch to // track a branch tip, or set commit to pin to an immutable SHA. args are // what the dep's CrafterBuildProject receives. They default to this - // project's own, so --target=, --march=, --debug and flags of its own - // such as --local reach a whole chain of sibling projects without being - // passed. Set them to forward something else: a copy without one of this - // project's flags, one with an extra --target=, or {} for nothing. + // project's own, read when the spec is made, so --target=, --march=, + // --debug and the project's own flags reach every sibling down a chain + // without being passed. Set them to forward something else: {} for + // nothing, or a list built from this project's args, such as one without + // a flag only this project reads. Give such a list to every sibling: a + // project that two paths load with two different lists is built twice, + // and the program ends up with both builds. struct GitProjectSpec { GitSource source; fs::path projectFile = "project.cpp"; std::vector args = ProjectArgs(); }; - // Clones the spec's git URL into the per-project external cache (keyed by - // url+branch+commit+args+projectFile), recursively LoadProject's the - // remote's project.cpp, and returns a stable Configuration* you can drop - // into cfg.dependencies. The Configuration is owned by an internal cache - // for the lifetime of the build; identical specs share one Configuration. + // Clones the spec's git URL into the external cache, recursively + // LoadProject's the remote's project.cpp, and returns a stable + // Configuration* you can drop into cfg.dependencies. The clone is keyed by + // url+branch+commit+projectFile alone, so every arg list builds in the + // same working tree, each into variant directories of its own. The + // Configuration is owned by an internal cache for the lifetime of the + // build, keyed by the clone and the args: identical specs share one. Configuration* GitProject(const GitProjectSpec& spec); // Specification for a local sibling crafter-build project (e.g. an