0.18.1: rules-qt and deps leave out another build system's output directory when they walk a source tree (#40)

Author: speak-agent

README.md

@@ -9,7 +9,7 @@ module name the member declares, and configures it there.
 
 ```toml
 [build-dependencies.mcpp]
-plugins = { version = "0.18.0", features = ["rules-spirv"], host-module = true }
+plugins = { version = "0.18.1", features = ["rules-spirv"], host-module = true }
 ```
 
 ```cpp

deps/deps.cppm

@@ -99,8 +99,9 @@ inline std::filesystem::path find_upward(std::filesystem::path start, std::strin
 }
 
 // Every regular file under `dir`, for an action's inputs. Version-control and
-// build-output directories are skipped: they change on every build and are no
-// part of what the installer reads.
+// build-output directories are skipped, and so is the output directory of any
+// other build system (`mcpp::plugins::tree`, 0.18.1): they change on every
+// build and are no part of what the installer reads.
 inline std::vector<std::string> files_under(const std::filesystem::path& dir) {
     std::vector<std::string> out;
     std::error_code ec;
@@ -112,7 +113,8 @@ inline std::vector<std::string> files_under(const std::filesystem::path& dir) {
         const auto name = it->path().filename().string();
         if (it->is_directory(ec)) {
             if (name == ".git" || name == "target" || name == "out" || name == "build" ||
-                name == "Install" || name == "vcpkg_installed")
+                name == "Install" || name == "vcpkg_installed" ||
+                mcpp::plugins::tree::build_output(it->path()))
                 it.disable_recursion_pending();
             continue;
         }

docs/deps.md

@@ -24,7 +24,7 @@ Module `mcpp.deps.archive`; engine floor: 2026.9.26.2.
 
 ```toml
 [build-dependencies.mcpp]
-plugins = { version = "0.18.0", features = ["deps-vcpkg"], host-module = true }
+plugins = { version = "0.18.1", features = ["deps-vcpkg"], host-module = true }
 ```
 
 ```cpp
@@ -197,7 +197,13 @@ One `prepare` action, `cmake -P` over a script the member writes
 (`<out dir>/deps-cmake/<name>.cmake`), configures, builds and installs the
 subproject into `<out dir>/deps-cmake/<name>/install`, its declared output
 directory; its inputs are the script and the subproject's files, so an edit to
-the subproject rebuilds it. The prefix is mapped as `deps-vcpkg` maps its own.
+the subproject rebuilds it. The subproject's files leave out `.git`, `target`,
+`out`, `build`, `Install`, `vcpkg_installed`, and from 0.18.1 the output
+directory of another build system inside it: one holding `CMakeCache.txt` (an
+IDE's `cmake-build-debug`), `.qmake.stash`, a `CACHEDIR.TAG` with the standard
+signature, or a `<name>.tlog` directory (MSBuild). A build made there by hand
+changes neither the inputs nor the key. The prefix is mapped as `deps-vcpkg`
+maps its own.
 `layout` names install directories other than `include/`, `lib/` and `bin/`;
 `prefix_path` becomes `CMAKE_PREFIX_PATH` (`mcpp::rules::qt::root()` for a
 subproject that finds Qt); `cache_args` carries `-D…`, `-G …` and a toolchain

docs/plugin-development.md

@@ -52,7 +52,7 @@ mcpp-index refuses such a package.
 
 ```toml
 [build-dependencies.mcpp]
-plugins = { version = "0.18.0", features = ["plugins-core"], host-module = true, reexport = true }
+plugins = { version = "0.18.1", features = ["plugins-core"], host-module = true, reexport = true }
 ```
 
 `reexport = true` is needed when the plugin's consumers import L2 modules in

docs/rules-qt.md

@@ -6,7 +6,7 @@
 
 ```toml
 [build-dependencies.mcpp]
-plugins = { version = "0.18.0", features = ["rules-qt"], host-module = true }
+plugins = { version = "0.18.1", features = ["rules-qt"], host-module = true }
 
 # The SDK and its version are the project's declaration.
 [target.'cfg(any(windows, linux, macos))'.xlings.workspace]
@@ -69,7 +69,7 @@ A package that enables `rules-qt` only to import `mcpp.rules.qt`, and has no `bu
 | `private_modules` | modules whose private headers are included |
 | `moc`, `moc_headers` | `moc_scan::project_headers` (default) scans the package's headers by content; `moc_scan::listed` takes `moc_headers` only |
 | `forms`, `resources` | `.ui` and `.qrc` files beside those in `[build] sources` |
-| `i18n` | `.ts` files beside those in `[build] sources`; `update_sources` runs `lupdate` as an action whose output is the `.ts` it rewrites; `tr_function_alias`; `deploy_to` (default `translations`); `out_dir` (default `<out dir>/qt/translations`); `qt_languages`: the linked modules' catalogs combined by `lconvert` into `qt_<language>.qm`, the file windeployqt writes |
+| `i18n` | `.ts` files beside those in `[build] sources`; `update_sources` runs `lupdate` as an action whose output is the `.ts` it rewrites, reading `sources`, or when that is empty the package's C++ sources and headers, found by the walk that finds moc's headers; `tr_function_alias`; `deploy_to` (default `translations`); `out_dir` (default `<out dir>/qt/translations`); `qt_languages`: the linked modules' catalogs combined by `lconvert` into `qt_<language>.qm`, the file windeployqt writes |
 | `deploy_plugins` | plugin directories placed beside the program; default `platforms` |
 | `deploy_software_gl` | Windows: `opengl32sw.dll` and `d3dcompiler_47.dll` beside the program |
 | `root`, `extra_roots` | level 1 of the SDK lookup |
@@ -79,6 +79,7 @@ A package that enables `rules-qt` only to import `mcpp.rules.qt`, and has no `bu
 ## Behaviour
 
 - `moc` runs for every header under the package root that declares `Q_OBJECT`, `Q_GADGET` or `Q_NAMESPACE`, and for a source that includes its own `<stem>.moc`; `uic` for `.ui`, `rcc` for `.qrc`, `lrelease` for `.ts`. Each is a `role = "source"` action with declared inputs; the outputs are under `<out dir>/qt/`.
+- The walk of the package root that finds those headers, and `lupdate`'s sources, leaves out `target`, `.git`, `mcpp-generated`, `vcpkg_installed`, `node_modules`, and from 0.18.1 the output directory of another build system, known by what it leaves there: `CMakeCache.txt` (a CMake build directory), `.qmake.stash` (qmake), a `CACHEDIR.TAG` with the standard signature, or a `<name>.tlog` directory (an MSBuild intermediate directory such as `x64/Release`, where a Visual Studio project writes its moc and uic output). Such a directory is known by what it holds, never by its name, so an `x64/` of sources is read.
 - The SDK's `bin/` (Windows) or `lib/` is a runtime search directory: the program's run path, `mcpp run`'s load path, `mcpp pack`'s closure, and on Windows the Qt DLLs placed beside the program. The plugin directories `deploy_plugins` names are deployed beside the program.
 - Under an MSVC compiler the rule adds `/Zc:__cplusplus` and `/permissive-`; on Linux, `-fPIC`. On macOS the modules are frameworks under `lib/`, compiled with `-F<root>/lib` and linked by their binaries' full paths. A resource compiled into a static library is registered with `Q_INIT_RESOURCE(<stem>)`.
 - A missing SDK, module or tool is a warning: the plan states what it can, and the build is where the absence fails.

mcpp.toml

@@ -1,7 +1,7 @@
 [package]
 name        = "plugins"
 namespace   = "mcpp"
-version     = "0.18.0"
+version     = "0.18.1"
 # The first mcpp release that states the build information (protocol 14),
 # places files in one edge, and renders structured diagnostics (mcpp#734).
 mcpp        = ">=2026.9.28.3"

rules/qt.cppm

@@ -187,7 +187,9 @@ inline std::string tool(std::span<const std::filesystem::path> roots, const char
 }
 
 // Files under the package root with one of `exts`, skipping build output and
-// version control. Sorted, so the plan does not depend on directory order.
+// version control, and the output directories of another build system
+// (`mcpp::plugins::tree`, 0.18.1). Sorted, so the plan does not depend on
+// directory order.
 inline std::vector<std::filesystem::path> project_files(std::initializer_list<std::string_view> exts) {
     std::vector<std::filesystem::path> out;
     const std::filesystem::path root = mcpp::manifest_dir();
@@ -199,7 +201,8 @@ inline std::vector<std::filesystem::path> project_files(std::initializer_list<st
         const auto name = it->path().filename().string();
         if (it->is_directory(ec)) {
             if (name == "target" || name == ".git" || name == "mcpp-generated" ||
-                name == "vcpkg_installed" || name == "node_modules")
+                name == "vcpkg_installed" || name == "node_modules" ||
+                mcpp::plugins::tree::build_output(it->path()))
                 it.disable_recursion_pending();
             continue;
         }

src/plugins.cppm

@@ -49,7 +49,7 @@ export namespace mcpp::plugins {
 //
 // One package, one version: the number lives in mcpp.toml, and the CI step
 // `the collection states its own version` compares the two.
-inline constexpr std::string_view version = "0.18.0";
+inline constexpr std::string_view version = "0.18.1";
 
 } // namespace mcpp::plugins
 
@@ -1448,3 +1448,47 @@ inline std::string module_root_for(std::string_view package_name,
 }
 
 } // namespace mcpp::plugins::surface
+
+// mcpp::plugins::tree -- the directories a walk of a source tree leaves out.
+//
+// SHARED BECAUSE TWO MEMBERS WALK A SOURCE TREE BY DEFAULT. `rules-qt` finds
+// the headers moc reads and the sources lupdate reads under the package, and
+// `deps` takes every file of a subproject as an input of its installation, and
+// `deps-cmake` as part of the installation's key. Neither may take what ANOTHER
+// build system generated there: a Visual Studio project built in the same
+// checkout leaves its moc and uic output under `x64/Release/`, and lupdate
+// given those files rewrites the translations, and a CMake build directory an
+// IDE made inside a subproject changes the key on every build.
+//
+// Such a directory is known by what its build system leaves in it, not by its
+// name: `x64/` is as often a directory of architecture-specific sources.
+export namespace mcpp::plugins::tree {
+
+// Whether `dir` is an output directory of another build system:
+//
+//   CMakeCache.txt   a CMake build tree (an IDE's `cmake-build-*`, `out/build/*`)
+//   .qmake.stash     a qmake build tree
+//   CACHEDIR.TAG     a directory its tool tags as a cache (https://bford.info/cachedir/)
+//   <name>.tlog/     an MSBuild intermediate directory (`x64/Release/`), where a
+//                    Visual Studio project writes the sources it generates
+//
+// A walk asks this of the directories under its root, never of the root: a
+// subproject configured in its own source directory holds CMakeCache.txt too.
+inline bool build_output(const std::filesystem::path& dir) {
+    namespace fs = std::filesystem;
+    std::error_code ec;
+    if (fs::is_regular_file(dir / "CMakeCache.txt", ec) || fs::is_regular_file(dir / ".qmake.stash", ec))
+        return true;
+    if (fs::is_regular_file(dir / "CACHEDIR.TAG", ec)) {
+        std::ifstream in(dir / "CACHEDIR.TAG", std::ios::binary);
+        std::string head(43, '\0');
+        in.read(head.data(), 43);
+        if (head == "Signature: 8a477f597d28d172789f06886806bc55") return true;
+    }
+    for (auto it = fs::directory_iterator(dir, fs::directory_options::skip_permission_denied, ec);
+         !ec && it != fs::directory_iterator(); it.increment(ec))
+        if (it->path().extension() == ".tlog" && it->is_directory(ec)) return true;
+    return false;
+}
+
+} // namespace mcpp::plugins::tree

tests/plugin-logic/build.mcpp

@@ -1,4 +1,5 @@
-// The deps members' decisions, one case per decision (mcpp#734, design §6).
+// The deps members' decisions, and the files rules-qt reads by default, one
+// case per decision (mcpp#734, design §6).
 // Each case states a build context, runs the member, and reads the action it
 // declared and the files it wrote. Nothing is installed or run.
 import std;
@@ -8,6 +9,7 @@ import mcpp.plugins.toolset;
 import mcpp.deps;          // the 0.16.0 names, for the compatibility case
 import mcpp.deps.vcpkg;
 import mcpp.deps.cmake;
+import mcpp.rules.qt;
 
 namespace t  = mcpp::plugins::testing;
 namespace ts = mcpp::plugins::toolset;
@@ -35,6 +37,28 @@ t::context with_subproject(t::context c) {
         .file("pkg/greet/CMakeLists.txt", "project(greet C)\n");
 }
 
+// Output directories of other build systems inside a tree `at`: an MSBuild
+// intermediate directory, a CMake build directory, a tagged cache directory and
+// one whose tag lacks the signature. `x64/` itself is a directory of sources.
+t::context with_foreign_output(t::context c, const std::string& at, const std::string& ext) {
+    return c.file(at + "/x64/simd" + ext, "class Simd { Q_OBJECT };\n")
+        .file(at + "/x64/Release/app.tlog/app.lastbuildstate")
+        .file(at + "/x64/Release/qt/uic/ui_form" + ext, "class Ui { Q_OBJECT };\n")
+        .file(at + "/cmake-build-debug/CMakeCache.txt")
+        .file(at + "/cmake-build-debug/gen/stale" + ext, "class Stale { Q_OBJECT };\n")
+        .file(at + "/cache/CACHEDIR.TAG", "Signature: 8a477f597d28d172789f06886806bc55\n")
+        .file(at + "/cache/blob" + ext)
+        .file(at + "/notag/CACHEDIR.TAG", "not a tag\n")
+        .file(at + "/notag/kept" + ext);
+}
+
+// A stand-in Qt SDK: the tools rules-qt looks for, never run.
+t::context with_qt(t::context c) {
+    for (auto const* tool : { "moc", "lupdate", "lrelease" })
+        c = c.file(std::string("qt/bin/") + tool).file(std::string("qt/bin/") + tool + ".exe");
+    return c.file("pkg/widget.h", "class Widget { Q_OBJECT };\n").file("pkg/app.ts");
+}
+
 int vcpkg_use(mcpp::deps::vcpkg::options o = {}) {
     o.libraries = {"fmt"};
     return mcpp::deps::vcpkg::use(o) ? 0 : 1;
@@ -378,6 +402,50 @@ int main(int argc, char** argv) {
                        "the script does not consult the cache");
           } },
 
+        { "cmake: another build system's output directory in a subproject is not part of the key",
+          with_foreign_output(with_subproject(t::row::windows_managed()), "pkg/greet", ".c"),
+          [] { return cmake_use(); },
+          [](const t::result& r, t::checker& c) {
+              std::string script;
+              for (auto const& f : r.files_under("out/deps-cmake/greet"))
+                  if (f.ends_with("greet.cmake")) script = r.file(f);
+              const auto from = script.find("set(listed [==[");
+              const auto listed = from == std::string::npos ? std::string()
+                                                            : script.substr(from, script.find("]==])", from) - from);
+              c.expect(listed.find("\nx64/simd.c\n") != std::string::npos, "a directory named x64 is listed");
+              c.expect(listed.find("\nnotag/kept.c\n") != std::string::npos,
+                       "a CACHEDIR.TAG without the signature marks nothing");
+              c.expect(listed.find("x64/Release") == std::string::npos, "an MSBuild intermediate directory is not");
+              c.expect(listed.find("cmake-build-debug") == std::string::npos, "a CMake build directory is not");
+              c.expect(listed.find("cache/") == std::string::npos, "a tagged cache directory is not");
+          } },
+
+        // ── rules-qt ────────────────────────────────────────────────────────
+        { "qt: moc and lupdate read the package's files, not another build system's output",
+          with_foreign_output(with_qt(t::row::linux_gcc()), "pkg", ".h"),
+          [] {
+              mcpp::rules::qt::options o;
+              o.root = "../qt";
+              o.modules = {"Core"};
+              o.i18n.ts = {"app.ts"};
+              o.i18n.update_sources = true;
+              return mcpp::rules::qt::compile(o) ? 0 : 1;
+          },
+          [](const t::result& r, t::checker& c) {
+              c.expect(r.exit_code == 0, "the member succeeds");
+              const auto u = r.line("mcpp:action=", {"qt:lupdate:app"});
+              c.expect(u.find("pkg/widget.h") != std::string::npos && u.find("pkg/x64/simd.h") != std::string::npos
+                       && u.find("pkg/notag/kept.h") != std::string::npos,
+                       "lupdate reads the package's sources, a directory named x64 among them");
+              c.expect(u.find("x64/Release") == std::string::npos && u.find("cmake-build-debug") == std::string::npos
+                       && u.find("pkg/cache/") == std::string::npos,
+                       "lupdate reads nothing another build system wrote");
+              c.expect(r.has_line("mcpp:action=", {"qt:moc:", "widget"}) && r.has_line("mcpp:action=", {"qt:moc:", "simd"}),
+                       "moc reads the package's headers");
+              c.expect(!r.has_line("mcpp:action=", {"qt:moc:", "ui_form"}) && !r.has_line("mcpp:action=", {"qt:moc:", "stale"}),
+                       "moc reads no header another build system wrote");
+          } },
+
         // ── compatibility ───────────────────────────────────────────────────
         { "compat: program_compilers keeps its 0.16.0 answer and says until when",
           t::row::linux_libcxx().file("llvm/bin/clang").file("llvm/bin/clang++"),

tests/plugin-logic/mcpp.toml

@@ -1,9 +1,9 @@
-# Fixture: the logic of the deps members, tested with `mcpp.plugins.testing`
-# against stated build contexts -- a Visual Studio row, a managed MSVC row, a
-# Linux GCC row and a Linux libc++ row -- on every host, with no foreign tool
-# installed or run. The build program is the test: a failed case fails the
-# build and prints the report; `target/**/plugins-testing/results.txt` holds
-# one verdict per case.
+# Fixture: the logic of the deps members and the files rules-qt reads by
+# default, tested with `mcpp.plugins.testing` against stated build contexts --
+# a Visual Studio row, a managed MSVC row, a Linux GCC row and a Linux libc++
+# row -- on every host, with no foreign tool installed or run. The build
+# program is the test: a failed case fails the build and prints the report;
+# `target/**/plugins-testing/results.txt` holds one verdict per case.
 [package]
 name        = "plugin-logic"
 version     = "0.1.0"
@@ -17,7 +17,7 @@ modules    = true
 import_std = true
 
 [build-dependencies.mcpp]
-plugins = { path = "../..", features = ["deps-vcpkg", "deps-cmake", "plugins-testing"], host-module = true }
+plugins = { path = "../..", features = ["deps-vcpkg", "deps-cmake", "rules-qt", "plugins-testing"], host-module = true }
 
 [targets.plugin-logic]
 kind = "bin"