rules-spirv: 两个只差目录的着色器映射到同一个输出,现在被规则拒绝并点名两者

输出名是着色器的 stem 加阶段,所以 `ui/text.vert` 与 `world/text.vert` 都产出
`text_vert.h`、都声明 `text_vert_spv`。

实测:在这条检查之前 ninja 会抓到重复输出 —— **所以它从来不是静默的**。但那条消息
点的是生成文件而不是两个着色器,以图加载失败的形式出现而不是这条规则的拒绝,而且
没有出路。每个阶段只有一个着色器的工程永远碰不到它,这是它活下来的原因;而按用途
分目录的图形工程是第一个会有两个的。

把目录并进名字不是修法:两个头文件只要进到同一个翻译单元,符号照样撞。

Author: Sunrisepeak

.github/workflows/ci.yml

@@ -90,6 +90,49 @@ jobs:
           grep -q '^magic=07230203' run-glslc.log
           rm -rf shaderc.tar.gz shaderc-2026.3
 
+      # TWO SHADERS THAT DIFFER ONLY BY DIRECTORY.
+      #
+      # The output name is the stem and the stage, so `a/x.vert` and `b/x.vert`
+      # both produce `x_vert.h` declaring `x_vert_spv`. Before this rule checked
+      # for it, ninja caught the duplicate output -- so it was never silent, but
+      # the message named the generated file and neither shader, arrived as a
+      # graph-loading failure rather than as this rule's refusal, and stated no
+      # way out. A project with one shader per stage never meets it, which is
+      # how it survived; a graphics project organising shaders by purpose is the
+      # first to have two.
+      - name: two shaders with one stem are refused, naming both
+        working-directory: tests/spirv-consumer
+        run: |
+          set -e
+          mkdir -p shaders/dup
+          cp shaders/scale.comp shaders/dup/scale.comp
+          # The fixture globs `shaders/*.comp`; widen it for this step only.
+          cp mcpp.toml mcpp.toml.bak
+          sed -i 's#shaders/\*.comp#shaders/**/*.comp#' mcpp.toml
+          rm -rf target
+          if "$MCPP" build > dup.log 2>&1; then
+            echo "FAIL: two shaders mapping to one output were accepted"
+            exit 1
+          fi
+          for needle in 'two shaders map to one output' 'shaders/scale.comp' \
+                        'shaders/dup/scale.comp' 'scale_comp_spv' 'rename one of them'; do
+            grep -q -- "$needle" dup.log || {
+              echo "FAIL: the refusal does not mention '$needle'"
+              tail -20 dup.log
+              exit 1
+            }
+          done
+          echo "ok: refused, naming both shaders, the symbol and the way out"
+          # …and the fixture still builds once the duplicate is gone, so this
+          # step cannot leave a project that refuses everything.
+          mv mcpp.toml.bak mcpp.toml
+          rm -rf shaders/dup target
+          "$MCPP" build > restored.log 2>&1 || {
+            echo "FAIL: the fixture no longer builds after the duplicate was removed"
+            tail -20 restored.log; exit 1; }
+          rm -f dup.log restored.log
+          echo "ok: and it builds again with one shader per stem"
+
       # A tool, not a rule: the header is written while the build program runs,
       # so there is no action to schedule. The second build is the measurement
       # that matters -- editing the data file must reach the binary, which is

rules/spirv.cppm

@@ -441,6 +441,49 @@ inline bool compile(std::span<const std::string> shaders, options opt = {}) {
     std::error_code ec;
     std::filesystem::create_directories(gen, ec);
 
+    // TWO SHADERS THAT DIFFER ONLY BY DIRECTORY PRODUCE ONE HEADER AND ONE
+    // SYMBOL, AND THAT HAS TO BE REFUSED HERE.
+    //
+    // The output name is the stem and the stage, as this rule documents, so
+    // `shaders/ui/text.vert` and `shaders/world/text.vert` both resolve to
+    // `text_vert.h` declaring `text_vert_spv`. Disambiguating by directory is
+    // not the fix: the SYMBOL would still collide the moment both headers
+    // reached one translation unit, and the naming rule is what consumers write
+    // `#include` lines against.
+    //
+    // Measured before this check existed: ninja caught it -- `multiple rules
+    // generate .../text_vert.h` -- so it was never silent. What it did not do
+    // is name the two SHADERS, say which rule produced them, or state the way
+    // out; and it arrives as a graph-loading failure rather than as this rule's
+    // refusal. A project with one shader per stage never meets it, which is why
+    // it survived: a graphics project organising shaders by purpose is the
+    // first to have two.
+    {
+        std::map<std::string, std::string> seen;   // output stem -> first source
+        for (auto const& src : shaders) {
+            const std::filesystem::path p(src);
+            const auto stage = stage_of(p.extension().string());
+            if (stage.empty()) continue;           // reported below, per source
+            const auto key = p.stem().string() + "_" + std::string(stage);
+            auto [it, fresh] = seen.try_emplace(key, src);
+            if (!fresh) {
+                std::println(std::cerr,
+                    "mcpp.rules.spirv: two shaders map to one output.\n"
+                    "    {}\n"
+                    "    {}\n"
+                    "  both produce `{}.h` declaring `{}`, because the name is the "
+                    "shader's stem\n"
+                    "  and its stage -- the directory is not part of it, and could not "
+                    "be: two\n"
+                    "  headers reaching one translation unit would still collide on the "
+                    "symbol.\n"
+                    "  fix: rename one of them, or compile only one.",
+                    it->second, src, key, symbol_of(p.stem().string(), stage));
+                return false;
+            }
+        }
+    }
+
     for (auto const& src : shaders) {
         const std::filesystem::path p(src);
         const auto stage = stage_of(p.extension().string());