From 1d0d8e1e2811aff0cf7345e0d10f043b0adc0981 Mon Sep 17 00:00:00 2001 From: catbot Date: Fri, 31 Jul 2026 11:11:38 +0000 Subject: [PATCH 1/3] feat(incremental): rebuild when an #included header changes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The staleness check compared an artifact against its own source and its module imports. Headers were in neither set: the scanner reads `import` lines, and a .cppm or .cpp keeps its mtime when a header it includes is edited — so the build reported nothing to do and left objects compiled against the previous contents. Same silent mixed-layout binary as issue 27, reached through #include instead of import. Ask the compiler what it actually opened. Every C++ and C compile now passes -MD -MF .d, and Check reads that depfile back through NewestPrerequisite, comparing every prerequisite's mtime against the artifact. A missing depfile (an object from a crafter-build that wrote none) or a prerequisite that no longer exists reads as "rebuild": neither is evidence of freshness. The parser unescapes make syntax rather than splitting on whitespace, since clang wraps depfiles onto continuation lines and escapes spaces in filenames. --- README.md | 3 + implementations/Crafter.Build-Clang.cpp | 11 +++- .../Crafter.Build-Implementation.cpp | 8 ++- implementations/Crafter.Build-Interface.cpp | 20 ++++-- implementations/Crafter.Build-Platform.cpp | 65 +++++++++++++++++++ interfaces/Crafter.Build-Platform.cppm | 12 ++++ 6 files changed, 111 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index f5347b2..fd508f9 100644 --- a/README.md +++ b/README.md @@ -121,12 +121,15 @@ Per-import precise tracking for both within-project and cross-project module dep - Touch `lib/Hello.cppm` → only consumers of `Hello` rebuild. - Touch `lib/Other.cppm` → only consumers of `Other` rebuild. +- Touch a header → only the units that `#include` it (directly or transitively) rebuild. - External CMake dep produces fresh `.a` files → whole project rebuilds (deliberately coarse — cmake-dep changes are rare). Diamond deps (`A → {B, C}; B → X; C → X`) build `X` exactly once via a `std::shared_future` cache. Tracking is derived from each translation unit's `import` statements, which are scanned when the sources are declared. Every kind of unit is scanned — primary module interfaces, partitions and implementation units alike — and an interface that imports a sibling module in the same `Configuration` also gets its compile ordered behind it. `cfg.dependencies` is often assigned *afterwards* — `AddTest` works that way — so `Build()` re-resolves any import that matched nothing at scan time before it compares mtimes. Without all of that, a consumer of a dependency's module carried no edge to it at all: adding a data member to that dependency's interface rebuilt the library, relinked the consumer, and left the consumer's object compiled against the old class layout. Nothing fails to link when a member is added, so the result was a working build and a crash later. +`#include`s are tracked separately, because scanning can't see them: a header pulls in more headers, and which ones are open depends on the preprocessor state at the point of inclusion. So every compile is asked to report what it actually opened — `clang -MD -MF .d`, written next to the object or BMI it belongs to — and the next staleness check reads that file back and compares every prerequisite's mtime against the artifact. C sources are covered the same way, and there they are the *only* dependency record. An artifact whose depfile is missing, or that names a prerequisite which no longer exists, is rebuilt once: neither state is evidence of freshness. Before this, a header edit changed no `.cppm` or `.cpp` mtime at all, so a build reported nothing to do and left objects compiled against the old contents — the same mixed-layout failure as above, reached through `#include` instead of `import`. + Everything that changes what gets built belongs in the variant id, since it names the `bin/` and `build/` directory. That includes project args crafter-build itself doesn't interpret: `crafter-build` and `crafter-build -- --no-webgpu` get separate directories rather than interleaving their outputs in one. The cached host PCMs under `/crafter.build/-/` are shared by every crafter-build on the machine, so they are invalidated by a hash of the module sources rather than by mtime — an mtime can't tell a newer PCM from one built by a different install. `crafter-build clean` removes the project's `bin/` and `build/` trees. It doesn't load `project.cpp`, so it still works when the project no longer compiles. diff --git a/implementations/Crafter.Build-Clang.cpp b/implementations/Crafter.Build-Clang.cpp index 4e7a8f9..c59df50 100644 --- a/implementations/Crafter.Build-Clang.cpp +++ b/implementations/Crafter.Build-Clang.cpp @@ -780,12 +780,15 @@ BuildResult Crafter::Build(Configuration& config, std::unordered_map fs::last_write_time(objPath))) { + // C sources carry their dependencies entirely in #includes, so the + // depfile the compile below writes is the whole record of what this + // object was built from beyond the .c itself. + if (!fs::exists(objPath) || (fs::exists(srcPath) && fs::last_write_time(srcPath) > fs::last_write_time(objPath)) || NewestPrerequisite(std::format("{}.d", objPath)) > fs::last_write_time(objPath)) { threads.emplace_back([&cFile, &buildDir, &buildError, &buildCancelled, &config, &includeFlags, &defineFlags, &userFlags, &cArchFlags, <oCompileFlags]() { Progress::Task task(std::format("Compiling {}.c", cFile.filename().string())); if (buildCancelled.load(std::memory_order_relaxed)) return; - std::string result = RunCommand(std::format("clang {}.c --target={}{} -O3{} -c{}{}{} -o {}_source.o", cFile.string(), config.target, cArchFlags, ltoCompileFlags, includeFlags, defineFlags, userFlags, (buildDir / cFile.filename()).string())); + std::string result = RunCommand(std::format("clang {0}.c --target={1}{2} -O3{3} -c{4}{5}{6} -MD -MF {7}_source.o.d -o {7}_source.o", cFile.string(), config.target, cArchFlags, ltoCompileFlags, includeFlags, defineFlags, userFlags, (buildDir / cFile.filename()).string())); if (result.empty()) return; bool expected = false; @@ -800,6 +803,10 @@ BuildResult Crafter::Build(Configuration& config, std::unordered_map fs::last_write_time(objPath))) { threads.emplace_back([&cFile, &buildDir, &buildError, &buildCancelled]() { Progress::Task task(std::format("Compiling {}.cu", cFile.filename().string())); diff --git a/implementations/Crafter.Build-Implementation.cpp b/implementations/Crafter.Build-Implementation.cpp index 579c09d..a0ba2b1 100644 --- a/implementations/Crafter.Build-Implementation.cpp +++ b/implementations/Crafter.Build-Implementation.cpp @@ -15,7 +15,10 @@ namespace Crafter { 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()); - if(!fs::exists(objPath) || std::max(fs::last_write_time(cppPath), sourceFloor) >= fs::last_write_time(objPath)) { + // 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); @@ -48,7 +51,8 @@ namespace Crafter { return; } - std::string result = RunCommand(std::format("{} {}.cpp -c -o {}_impl.o", clang, path.string(), (buildDir/path.filename()).string())); + // -MD leaves _impl.o.d beside the object for Check to read. + std::string result = RunCommand(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)) { diff --git a/implementations/Crafter.Build-Interface.cpp b/implementations/Crafter.Build-Interface.cpp index b92e9c6..526cf3b 100644 --- a/implementations/Crafter.Build-Interface.cpp +++ b/implementations/Crafter.Build-Interface.cpp @@ -15,7 +15,13 @@ namespace Crafter { checked = true; std::string pcmPath = std::format("{}.pcm", (pcmDir/path.filename()).generic_string()); std::string cppmPath = std::format("{}.cppm", path.generic_string()); - if(fs::exists(pcmPath) && std::max(fs::last_write_time(cppmPath), sourceFloor) < fs::last_write_time(pcmPath)) { + // NewestPrerequisite covers the headers this partition #includes — + // they are inputs to the BMI just as much as the .cppm is, and the + // .cppm's own mtime says nothing about them. It only ever bounds + // *this* artifact, so it goes in the comparison below and not into + // the `sourceFloor` handed to the recursive Checks: each of those + // reads its own depfile. + if(fs::exists(pcmPath) && std::max({fs::last_write_time(cppmPath), sourceFloor, NewestPrerequisite(std::format("{}.d", pcmPath))}) < fs::last_write_time(pcmPath)) { fs::file_time_type pcmTime = fs::last_write_time(pcmPath); for(ModulePartition* dependency : partitionDependencies) { if(dependency->Check(pcmDir, sourceFloor)) { @@ -71,7 +77,9 @@ namespace Crafter { return; } - std::string result = RunCommand(std::format("{} {}.cppm --precompile -o {}.pcm", clang, path.string(), (pcmDir/path.filename()).string())); + // -MD records every header the preamble pulled in, next to the BMI as + // .pcm.d, so the next Check can see an edit to one of them. + std::string result = RunCommand(std::format("{0} {1}.cppm --precompile -MD -MF {2}.pcm.d -o {2}.pcm", clang, path.string(), (pcmDir/path.filename()).string())); if (!result.empty()) { bool expected = false; @@ -103,7 +111,9 @@ namespace Crafter { checked = true; std::string pcmPath = std::format("{}.pcm", (pcmDir/path.filename()).generic_string()); std::string cppmPath = std::format("{}.cppm", path.generic_string()); - if(fs::exists(pcmPath) && std::max(fs::last_write_time(cppmPath), sourceFloor) < fs::last_write_time(pcmPath)) { + // See ModulePartition::Check — the depfile clang wrote beside the BMI + // is the only record of which headers this interface unit included. + if(fs::exists(pcmPath) && std::max({fs::last_write_time(cppmPath), sourceFloor, NewestPrerequisite(std::format("{}.d", pcmPath))}) < fs::last_write_time(pcmPath)) { fs::file_time_type pcmTime = fs::last_write_time(pcmPath); // Every partition gets Check()ed even once one is known stale: // Compile() drives partition rebuilds off their own @@ -191,7 +201,9 @@ namespace Crafter { return; } - std::string result = RunCommand(std::format("{} {}.cppm --precompile -o {}.pcm", clang, path.string(), (pcmDir/path.filename()).string())); + // -MD records every header the preamble pulled in, next to the BMI as + // .pcm.d, so the next Check can see an edit to one of them. + std::string result = RunCommand(std::format("{0} {1}.cppm --precompile -MD -MF {2}.pcm.d -o {2}.pcm", clang, path.string(), (pcmDir/path.filename()).string())); if (!result.empty()) { bool expected = false; diff --git a/implementations/Crafter.Build-Platform.cpp b/implementations/Crafter.Build-Platform.cpp index 62ee0ab..051dcae 100644 --- a/implementations/Crafter.Build-Platform.cpp +++ b/implementations/Crafter.Build-Platform.cpp @@ -164,6 +164,71 @@ fs::path Crafter::GetCrafterBuildHome() { throw std::runtime_error(msg); } +fs::file_time_type Crafter::NewestPrerequisite(const fs::path& depFile) { + std::ifstream in(depFile, std::ios::binary); + if (!in) return fs::file_time_type::max(); + std::ostringstream buffer; + buffer << in.rdbuf(); + const std::string text = std::move(buffer).str(); + + // Make-rule tokenizing, as clang writes it: `target: prereq prereq`, with a + // trailing '\' continuing the rule onto the next line (clang wraps at ~80 + // columns, so any real depfile has several), '\ ' and '\#' escaping a + // character into a filename, and '$$' standing for a literal '$'. A + // backslash that is none of those is a Windows path separator and stays. + std::vector tokens; + std::string token; + auto flush = [&tokens, &token]() { + if (!token.empty()) { + tokens.push_back(token); + token.clear(); + } + }; + for (std::size_t i = 0; i < text.size(); ++i) { + const char c = text[i]; + const char next = i + 1 < text.size() ? text[i + 1] : '\0'; + if (c == '\\' && (next == '\n' || next == '\r')) { + flush(); + ++i; + } else if (c == '\\' && (next == ' ' || next == '\t' || next == '#')) { + token += next; + ++i; + } else if (c == '$' && next == '$') { + token += '$'; + ++i; + } else if (c == ' ' || c == '\t' || c == '\n' || c == '\r') { + flush(); + } else { + token += c; + } + } + flush(); + + // A token ending in ':' names a rule target, not an input. The first one + // closes the target list (and a Windows `C:\build\x.o:` still ends in ':', + // where splitting on the first colon would not); a later one opens another + // rule, as `-MP` phony targets do, whose name is not a file to stat. + bool sawTarget = false; + fs::file_time_type newest = fs::file_time_type::min(); + for (const std::string& prerequisite : tokens) { + if (prerequisite.ends_with(':')) { + sawTarget = true; + continue; + } + if (!sawTarget) continue; + std::error_code ec; + const fs::file_time_type stamp = fs::last_write_time(prerequisite, ec); + // A prerequisite that has since been deleted makes the recorded set + // unusable as evidence — the source that included it must have changed + // too, and rebuilding is what writes a depfile that no longer names it. + if (ec) return fs::file_time_type::max(); + if (stamp > newest) newest = stamp; + } + // No rule at all: a truncated or empty depfile proves nothing. + if (!sawTarget) return fs::file_time_type::max(); + return newest; +} + bool Crafter::MatchGlob(std::string_view glob, std::string_view name) { std::size_t gi = 0; std::size_t ni = 0; diff --git a/interfaces/Crafter.Build-Platform.cppm b/interfaces/Crafter.Build-Platform.cppm index eeb6fa9..b91ea12 100644 --- a/interfaces/Crafter.Build-Platform.cppm +++ b/interfaces/Crafter.Build-Platform.cppm @@ -27,6 +27,18 @@ namespace Crafter { // module sources, wasi-runtime/, etc). Honors CRAFTER_BUILD_HOME; otherwise // derives /share/crafter-build from the running executable's path. export CRAFTER_API fs::path GetCrafterBuildHome(); + // Newest mtime among the prerequisites a compiler recorded in `depFile` + // (clang's `-MD -MF .d`). This is how a build step learns which + // headers its source pulled in: the module scanner only reads `import` + // lines, so an `#include`d file is invisible to it until the compiler + // reports what it actually opened. + // + // Returns file_time_type::max() when freshness cannot be proven — no + // depfile (nothing has compiled this artifact since depfiles were emitted, + // including every object left over from an older crafter-build) or a + // prerequisite that no longer exists. Callers compare the result against + // their artifact's mtime, so max() reads as "rebuild". + fs::file_time_type NewestPrerequisite(const fs::path& depFile); // Wildcard name matching ('*', '?') shared by the test and lint verbs. bool MatchGlob(std::string_view glob, std::string_view name); // Empty `globs` matches everything. -- 2.47.3 From f66120a8eba71382c47796d92f74110b2fa0b479 Mon Sep 17 00:00:00 2001 From: catbot Date: Fri, 31 Jul 2026 11:11:44 +0000 Subject: [PATCH 2/3] fix(incremental): relink when a C or CUDA object is rebuilt The C compile loop sets no repack flag, and the "is any object newer than the archive" sweep only walked interfaces and implementations. So editing a .c recompiled its object and then linked nothing: the archive and the executable kept the previous one. Surfaced by the header-change test, where a rebuilt counter.c produced a binary still printing the old value. --- implementations/Crafter.Build-Clang.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/implementations/Crafter.Build-Clang.cpp b/implementations/Crafter.Build-Clang.cpp index c59df50..9262475 100644 --- a/implementations/Crafter.Build-Clang.cpp +++ b/implementations/Crafter.Build-Clang.cpp @@ -1109,6 +1109,21 @@ BuildResult Crafter::Build(Configuration& config, std::unordered_map& sources) { + for (const fs::path& source : sources) { + if (objNewer(buildDir / std::format("{}_source.o", source.filename().string()))) return true; + } + return false; + }; + if (sourceObjNewer(config.cFiles) || sourceObjNewer(config.cuda)) { + buildResult.repack = true; + } + } } } } -- 2.47.3 From 7975cb1df8b0f7d5eb2e4f3f13fb2d3f975e7e2e Mon Sep 17 00:00:00 2001 From: catbot Date: Fri, 31 Jul 2026 11:11:49 +0000 Subject: [PATCH 3/3] test: header-change incrementality across every compile path MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit One header per pass, asserting both directions — the objects that include it recompile, the ones that don't are untouched — then running the binary, since "was recompiled" only matters if the program agrees with itself. Covers the module interface (a macro in its global module fragment decides an exported class's layout), the implementation unit, a C source, an idle rebuild that must recompile nothing, and an object whose depfile is gone. The implementation unit's header has a space in its name so the depfile spells it escaped. --- project.cpp | 1 + .../fixture/lib/Widget.cpp | 11 + .../fixture/lib/Widget.cppm | 21 ++ .../fixture/lib/counter-limit-grown.h.in | 7 + .../fixture/lib/counter-limit.h | 8 + .../fixture/lib/counter.c | 8 + .../fixture/lib/widget count-grown.h.in | 7 + .../fixture/lib/widget count.h | 12 ++ .../fixture/lib/widget-layout-grown.h.in | 9 + .../fixture/lib/widget-layout.h | 11 + .../IncrementalHeaderChange/fixture/main.cpp | 19 ++ tests/IncrementalHeaderChange/main.cpp | 203 ++++++++++++++++++ 12 files changed, 317 insertions(+) create mode 100644 tests/IncrementalHeaderChange/fixture/lib/Widget.cpp create mode 100644 tests/IncrementalHeaderChange/fixture/lib/Widget.cppm create mode 100644 tests/IncrementalHeaderChange/fixture/lib/counter-limit-grown.h.in create mode 100644 tests/IncrementalHeaderChange/fixture/lib/counter-limit.h create mode 100644 tests/IncrementalHeaderChange/fixture/lib/counter.c create mode 100644 tests/IncrementalHeaderChange/fixture/lib/widget count-grown.h.in create mode 100644 tests/IncrementalHeaderChange/fixture/lib/widget count.h create mode 100644 tests/IncrementalHeaderChange/fixture/lib/widget-layout-grown.h.in create mode 100644 tests/IncrementalHeaderChange/fixture/lib/widget-layout.h create mode 100644 tests/IncrementalHeaderChange/fixture/main.cpp create mode 100644 tests/IncrementalHeaderChange/main.cpp diff --git a/project.cpp b/project.cpp index 33d04a7..f3e5af1 100644 --- a/project.cpp +++ b/project.cpp @@ -109,6 +109,7 @@ extern "C" Configuration CrafterBuildProject(std::span a 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("CleanProject").Dependencies({ CrafterBuildLib.get() }); cfg.AddTest("ShaderCompile").Dependencies({ CrafterBuildLib.get() }); cfg.AddTest("StandardArgs").Dependencies({ CrafterBuildLib.get() }); diff --git a/tests/IncrementalHeaderChange/fixture/lib/Widget.cpp b/tests/IncrementalHeaderChange/fixture/lib/Widget.cpp new file mode 100644 index 0000000..cf222f1 --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/lib/Widget.cpp @@ -0,0 +1,11 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +module; +#include "widget count.h" +module Widget; +import std; + +std::size_t WidgetSizeInLibrary() { return sizeof(Widget); } + +std::int64_t WidgetCountInLibrary() { return WIDGET_COUNT; } diff --git a/tests/IncrementalHeaderChange/fixture/lib/Widget.cppm b/tests/IncrementalHeaderChange/fixture/lib/Widget.cppm new file mode 100644 index 0000000..3240a22 --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/lib/Widget.cppm @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +module; +// The whole point of the fixture: an input to this interface unit that the +// module scanner cannot see. WIDGET_SLOTS comes from a header, so the class +// layout below changes without Widget.cppm being touched. +#include "widget-layout.h" +export module Widget; +import std; + +export struct Widget { + std::array slots; +}; + +// Out-of-line in the library's implementation unit, so the value reflects the +// layout the *library* was compiled against rather than the caller's — same +// reasoning as the IncrementalInterfaceChange fixture. +export std::size_t WidgetSizeInLibrary(); +// Reads a macro from a header only the implementation unit includes. +export std::int64_t WidgetCountInLibrary(); diff --git a/tests/IncrementalHeaderChange/fixture/lib/counter-limit-grown.h.in b/tests/IncrementalHeaderChange/fixture/lib/counter-limit-grown.h.in new file mode 100644 index 0000000..97ae023 --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/lib/counter-limit-grown.h.in @@ -0,0 +1,7 @@ +/* SPDX-License-Identifier: LGPL-3.0-only + SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® */ + +/* Copied over lib/counter-limit.h mid-test. */ +#pragma once + +#define COUNTER_LIMIT 9 diff --git a/tests/IncrementalHeaderChange/fixture/lib/counter-limit.h b/tests/IncrementalHeaderChange/fixture/lib/counter-limit.h new file mode 100644 index 0000000..f83ba18 --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/lib/counter-limit.h @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: LGPL-3.0-only + SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® */ + +/* Included from counter.c — the C compile path keeps all of its dependencies in + #includes, so it has nothing but the depfile to go on. */ +#pragma once + +#define COUNTER_LIMIT 5 diff --git a/tests/IncrementalHeaderChange/fixture/lib/counter.c b/tests/IncrementalHeaderChange/fixture/lib/counter.c new file mode 100644 index 0000000..e1b99ee --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/lib/counter.c @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: LGPL-3.0-only + SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® */ + +#include "counter-limit.h" + +long CounterLimitInLibrary(void) { + return COUNTER_LIMIT; +} diff --git a/tests/IncrementalHeaderChange/fixture/lib/widget count-grown.h.in b/tests/IncrementalHeaderChange/fixture/lib/widget count-grown.h.in new file mode 100644 index 0000000..89801ab --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/lib/widget count-grown.h.in @@ -0,0 +1,7 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +// Copied over lib/widget count.h mid-test. +#pragma once + +#define WIDGET_COUNT 2 diff --git a/tests/IncrementalHeaderChange/fixture/lib/widget count.h b/tests/IncrementalHeaderChange/fixture/lib/widget count.h new file mode 100644 index 0000000..f310f51 --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/lib/widget count.h @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +// Included from Widget.cpp, the module's implementation unit — nothing else +// sees it, so an edit here must rebuild that one object and nothing more. +// +// The space in the filename is deliberate: clang escapes it as `widget\ count.h` +// in the depfile, so a build that reads depfiles has to unescape make syntax +// rather than splitting the line on whitespace. +#pragma once + +#define WIDGET_COUNT 1 diff --git a/tests/IncrementalHeaderChange/fixture/lib/widget-layout-grown.h.in b/tests/IncrementalHeaderChange/fixture/lib/widget-layout-grown.h.in new file mode 100644 index 0000000..d4c0485 --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/lib/widget-layout-grown.h.in @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +// Copied over lib/widget-layout.h mid-test: one more slot in the exported +// class. Kept as a .h.in so the original header is the only one any source +// #includes. +#pragma once + +#define WIDGET_SLOTS 2 diff --git a/tests/IncrementalHeaderChange/fixture/lib/widget-layout.h b/tests/IncrementalHeaderChange/fixture/lib/widget-layout.h new file mode 100644 index 0000000..081caa7 --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/lib/widget-layout.h @@ -0,0 +1,11 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +// Included from Widget.cppm's global module fragment. WIDGET_SLOTS decides the +// layout of the exported class, so growing it (the test copies +// widget-layout-grown.h.in over this file) invalidates the BMI and every object +// compiled against it — while leaving Widget.cppm itself untouched, which is +// exactly what the mtime comparison used to miss. +#pragma once + +#define WIDGET_SLOTS 1 diff --git a/tests/IncrementalHeaderChange/fixture/main.cpp b/tests/IncrementalHeaderChange/fixture/main.cpp new file mode 100644 index 0000000..b1d8639 --- /dev/null +++ b/tests/IncrementalHeaderChange/fixture/main.cpp @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: LGPL-3.0-only +// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® + +import std; +import Widget; + +extern "C" long CounterLimitInLibrary(); + +// Prints " " and exits 1 when +// the two sizes disagree. The sizes are the mixed-layout check; the count and +// the limit report which build of the library's own objects got linked in, so a +// stale implementation object or C object shows up as an old value rather than +// as silence. +int main() { + std::size_t here = sizeof(Widget); + std::size_t inLibrary = WidgetSizeInLibrary(); + std::print("{} {} {} {}", here, inLibrary, WidgetCountInLibrary(), CounterLimitInLibrary()); + return here == inLibrary ? 0 : 1; +} diff --git a/tests/IncrementalHeaderChange/main.cpp b/tests/IncrementalHeaderChange/main.cpp new file mode 100644 index 0000000..bda0682 --- /dev/null +++ b/tests/IncrementalHeaderChange/main.cpp @@ -0,0 +1,203 @@ +// 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; + +// Editing a header must rebuild everything that #includes it. The staleness +// check used to compare an artifact against its own source and its module +// imports only — and the module scanner reads `import` lines, so a header was +// invisible to it. A build after a header-only edit reported nothing to do and +// left objects compiled against the previous contents: the same silent +// mixed-layout binary as issue #27, reached through #include instead. +// +// Each pass below edits exactly one header and asserts both directions — the +// objects that include it are recompiled, the ones that don't are left alone — +// then runs the binary, because "was recompiled" is only interesting if the +// resulting program agrees with itself. + +namespace { + std::int32_t Failures = 0; + + void Check(bool cond, std::string_view msg) { + if (!cond) { + std::println(std::cerr, "FAIL: {}", msg); + ++Failures; + } + } + + // The fixture is mutated during the run, so work on a copy outside the repo. + fs::path StageFixture() { + fs::path source = fs::current_path() / "tests" / "IncrementalHeaderChange" / "fixture"; + fs::path staged = fs::temp_directory_path() / "crafter-build-incremental-header-change"; + fs::remove_all(staged); + fs::copy(source, staged, fs::copy_options::recursive); + return staged; + } + + // Swap -grown.h.in in for .h. The replacement text lives in a + // file rather than a string literal so the header the fixture #includes is + // the only one under that name, whichever variant is in place. + void Grow(const fs::path& header) { + fs::path grown = header.parent_path() / std::format("{}-grown.h.in", header.stem().string()); + fs::copy_file(grown, header, fs::copy_options::overwrite_existing); + // copy_file carries the source's mtime across, which would leave the + // rewritten header looking older than the objects built from it. + fs::last_write_time(header, fs::file_time_type::clock::now()); + } + + std::unique_ptr MakeLib(const fs::path& staged) { + auto lib = std::make_unique(); + lib->path = staged / "lib"; + lib->name = "widget"; + lib->outputName = "widget"; + lib->target = HostTarget(); + lib->type = ConfigurationType::LibraryStatic; + std::array ifaces = { "Widget" }; + std::array impls = { "Widget" }; + lib->GetInterfacesAndImplementations(ifaces, impls); + // cFiles are resolved against the cwd at build time, so spell it out. + lib->cFiles = { staged / "lib" / "counter" }; + return lib; + } + + Configuration MakeApp(const fs::path& staged, Configuration* lib) { + Configuration app; + app.path = staged; + app.name = "widget-app"; + app.outputName = "widget-app"; + app.target = HostTarget(); + app.type = ConfigurationType::Executable; + std::array ifaces = {}; + std::array impls = { "main" }; + app.GetInterfacesAndImplementations(ifaces, impls); + app.dependencies = { lib }; + return app; + } + + bool BuildOk(Configuration& app, std::string_view label) { + // A fresh depResults per pass: the map memoizes each Configuration's + // build for the duration of one pass, so reusing it would skip the + // library's second build entirely. + std::unordered_map> depResults; + std::mutex depMutex; + BuildResult r = Build(app, depResults, depMutex); + if (!r.result.empty()) { + std::println(std::cerr, "FAIL: {} build failed: {}", label, r.result); + ++Failures; + return false; + } + return true; + } + + // " " — see + // the fixture's main.cpp. + void CheckRun(const fs::path& binary, std::string_view expected, std::string_view label) { + auto r = RunCommandWithTimeout(binary.string(), std::chrono::seconds(30)); + Check(r.exitCode == 0 && !r.crashed && !r.timedOut && r.output == expected, std::format("{}: expected '{}', got '{}' (exit={})", label, expected, r.output, r.exitCode)); + } +} + +int main() { + fs::path staged = StageFixture(); + std::unique_ptr lib = MakeLib(staged); + Configuration app = MakeApp(staged, lib.get()); + + fs::path binary = app.BinDir() / "widget-app"; + // One artifact per compile path a header can reach: the module interface + // (BMI plus the object made from it), the module's implementation unit, a C + // source, and the consumer that imports the module. + fs::path interfacePcm = lib->PcmDir() / "Widget.pcm"; + fs::path interfaceObject = lib->BuildDir() / "Widget.o"; + fs::path libraryObject = lib->BuildDir() / "Widget_impl.o"; + fs::path counterObject = lib->BuildDir() / "counter_source.o"; + fs::path consumerObject = app.BuildDir() / "main_impl.o"; + + if (!BuildOk(app, "first pass")) { + std::println(std::cerr, "{} assertions failed", Failures); + return 1; + } + CheckRun(binary, "8 8 1 5", "first pass"); + + auto stamps = [&]() { + return std::array{ + fs::last_write_time(interfacePcm), + fs::last_write_time(interfaceObject), + fs::last_write_time(libraryObject), + fs::last_write_time(counterObject), + fs::last_write_time(consumerObject), + }; + }; + + // Nothing changed: the depfiles must not read as staleness of their own, + // or every build would recompile the world. + { + std::array before = stamps(); + if (BuildOk(app, "idle pass")) { + Check(stamps() == before, "an idle rebuild recompiles nothing"); + } + } + + // A header only the module's implementation unit includes. Its name carries + // a space, so the depfile spells it escaped. + { + std::array before = stamps(); + Grow(staged / "lib" / "widget count.h"); + if (BuildOk(app, "implementation header pass")) { + std::array after = stamps(); + Check(after[2] > before[2], "implementation object is recompiled after a header it includes changes"); + Check(after[0] == before[0], "interface BMI is left alone by a header it does not include"); + Check(after[3] == before[3], "C object is left alone by a header it does not include"); + Check(after[4] == before[4], "consumer object is left alone by a header it does not include"); + CheckRun(binary, "8 8 2 5", "implementation header pass"); + } + } + + // A header only the C source includes. + { + std::array before = stamps(); + Grow(staged / "lib" / "counter-limit.h"); + if (BuildOk(app, "C header pass")) { + std::array after = stamps(); + Check(after[3] > before[3], "C object is recompiled after a header it includes changes"); + Check(after[2] == before[2], "implementation object is left alone by a header it does not include"); + CheckRun(binary, "8 8 2 9", "C header pass"); + } + } + + // A header the interface unit includes, changing the layout of an exported + // class: the BMI and everything compiled against it has to follow. + { + std::array before = stamps(); + Grow(staged / "lib" / "widget-layout.h"); + if (BuildOk(app, "interface header pass")) { + std::array after = stamps(); + Check(after[0] > before[0], "interface BMI is rebuilt after a header it includes changes"); + Check(after[1] > before[1], "interface object is rebuilt after a header it includes changes"); + Check(after[2] > before[2], "implementation object follows the rebuilt BMI"); + Check(after[4] > before[4], "consumer object follows the rebuilt BMI"); + CheckRun(binary, "16 16 2 9", "interface header pass"); + } + } + + // An object built before depfiles were emitted at all — an upgrade over an + // existing build directory — has no record of what it included, so the one + // safe reading is "rebuild it once". + { + std::array before = stamps(); + fs::remove(lib->BuildDir() / "Widget_impl.o.d"); + if (BuildOk(app, "missing depfile pass")) { + std::array after = stamps(); + Check(after[2] > before[2], "an object whose dependency record is missing is rebuilt"); + Check(after[3] == before[3], "the objects that still have one are left alone"); + } + } + + if (Failures > 0) { + std::println(std::cerr, "{} assertions failed", Failures); + return 1; + } + return 0; +} -- 2.47.3