fix(build): try atomic no-replace for absent status records

Author: Sunrisepeak

src/build/schedule/compiler_transaction.cpp

@@ -32,9 +32,25 @@ bool replace_record(const fs::path& path,std::string_view bytes,std::string* dia
             std::error_code sourceError, targetError;
             const auto source=fs::symlink_status(temporary,sourceError);
             const auto target=fs::symlink_status(path,targetError);
-            *diagnostic=std::format("rename temporary (condition {}, native {}; source regular {} ec {}; target exists {} ec {})",
+            // A final status is a new name. If the replace form itself was
+            // refused as invalid while that name is absent, try the atomic
+            // no-replace form on the exact same source and destination. Its
+            // refusal is preserved as evidence rather than hidden by a loop.
+            int noReplaceCode=0;
+            const bool targetAbsent=target.type()==fs::file_type::not_found
+                || targetError==std::errc::no_such_file_or_directory;
+            if(renamed.error().code==os::errc::invalid && fs::is_regular_file(source)
+               && targetAbsent) {
+                auto noReplace=os::fs::rename(temporary,path,false);
+                if(noReplace) {
+                    *diagnostic="replace form refused absent target; no-replace published";
+                    return true;
+                }
+                noReplaceCode=static_cast<int>(noReplace.error().code);
+            }
+            *diagnostic=std::format("rename temporary (condition {}, native {}; source regular {} ec {}; target exists {} ec {}; no-replace condition {})",
                 static_cast<int>(renamed.error().code),renamed.error().native,
-                fs::is_regular_file(source),sourceError.value(),fs::exists(target),targetError.value());
+                fs::is_regular_file(source),sourceError.value(),fs::exists(target),targetError.value(),noReplaceCode);
         }
     } else if(!written) {
         fail("write/flush temporary");

src/build/schedule/compiler_transaction.cppm

@@ -3,6 +3,7 @@
 export module mcpp.build.schedule.compiler_transaction;
 import std;
 import mcpplibs.os.fs;
+import mcpplibs.os.error;
 import mcpplibs.os.process;
 import mcpplibs.os.ipc;
 import mcpplibs.os.dirs;

src/build/schedule/detach_codegen.cppm

@@ -893,6 +893,8 @@ int supervise(const std::filesystem::path& slot,
             record_supervisor_error(slot,std::format("cannot publish compiler final status: {}",status_failure));
             return 1;
         }
+        if(!status_failure.empty())
+            std::println(std::cerr,"mcpp: {}",status_failure);
         if(!transactions::release_reservation(permit->reservation,attempt.directory)) {
             record_supervisor_error(slot,"cannot release compiler reservation");return 1;
         }

tests/unit/test_compiler_transaction.cpp

@@ -6,6 +6,7 @@ import mcpp.run;
 import mcpp.invocation;
 import mcpp.runtime.elf;
 import mcpplibs.os.platform;
+import mcpplibs.os.fs;
 
 namespace tx = mcpp::build::schedule::transaction;
 namespace fs = std::filesystem;
@@ -250,6 +251,17 @@ TEST(CompilerTransaction, ReaderHeldTargetKeepsAnAtomicRecord) {
     EXPECT_EQ(Transaction::contents(record),replaced?"new":"old");
     EXPECT_EQ(std::string(std::istreambuf_iterator<char>(held),std::istreambuf_iterator<char>()),"old");
 }
+TEST(CompilerTransaction, NoReplacePublishesOnlyAnAbsentRecord) {
+    Transaction t;
+    const auto source=t.root/"new";
+    const auto target=t.root/"status";
+    std::ofstream(source)<<"ready";
+    ASSERT_TRUE(mcpplibs::os::fs::rename(source,target,false));
+    EXPECT_EQ(Transaction::contents(target),"ready");
+    std::ofstream(source)<<"later";
+    EXPECT_FALSE(mcpplibs::os::fs::rename(source,target,false));
+    EXPECT_EQ(Transaction::contents(target),"ready");
+}
 TEST(CompilerTransaction, RecordOpenAppearanceDriver) {
     if(!mcpp::invocation::get("MCPP_TEST_RECORD_OPEN_DRIVER"))GTEST_SKIP()<<"subprocess driver";
     auto record=tx::read("record","schema");