fix: decide the std module coroutine note from its command

The std module precompile's error carries the command, not the compiler's
diagnostics, which reach the terminal directly (measured on #781's Windows
CI, run 37802975713, e2e 892 case A). The note there rests on the command:
the MSVC STL's std.ixx or std.compat.ixx at C++23 or later for a
*-windows-msvc target, and a probe of the same compiler that finds
__cpp_impl_coroutine undefined. The ninja path keeps reading the symptom
from its output, which carries both.

Author: Sunrisepeak

src/toolchain/msvc_coroutines.cppm

@@ -17,11 +17,20 @@
 //     coroutine diagnostic can run (measured, probe PR #788).
 //
 // ASKED ONLY AFTER A FAILURE, OF THE COMPILER THAT FAILED. The command is read
-// from the failure output itself — the std module's `command:` line, or the
-// command ninja prints after `FAILED:` — so the plan path and the fast path
-// share this one function and no record has to be written in advance. A
-// successful build never reaches it, and when the compiler or the STL changes,
-// either the symptom or the probe stops matching and the note disappears.
+// from the failure itself, so no record has to be written in advance, and a
+// successful build never reaches this module:
+//
+//   * a compile ninja ran: the output carries the command after `FAILED:` and
+//     the compiler's diagnostics, so the symptom is read from it (`advice`);
+//     the plan path and the fast path share that one function;
+//   * the std module precompile: its error carries the `command:` line but not
+//     the compiler's diagnostics, which reach the terminal directly (measured
+//     on #781's Windows CI). The answer there rests on the command alone
+//     (`std_module_advice`): the MSVC STL's `std.ixx` at C++23 or later
+//     includes <generator>, which cannot compile without the macro.
+//
+// When the compiler or the STL changes, the probe stops matching and the note
+// disappears.
 
 export module mcpp.toolchain.msvc_coroutines;
 
@@ -63,6 +72,13 @@ std::optional<FailedCommand> failed_command_in(std::string_view output);
 // only after the symptom and the command have both matched.
 std::string advice(std::string_view output, const ProbeFn& probe);
 
+// The note for a failed std module precompile, from its error message: the
+// `command:` line compiles the MSVC STL's `std.ixx` or `std.compat.ixx` at
+// C++23 or later for a `*-windows-msvc` target, and the probe finds the macro
+// undefined. Empty otherwise.
+std::string std_module_advice(std::string_view message, const ProbeFn& probe);
+std::string std_module_advice(std::string_view message);
+
 // The probe that runs the compiler: `-dM -E` of an empty unit, with the same
 // target and standard and without the driver's configuration file.
 std::optional<Probe> run_probe(const FailedCommand& cmd);
@@ -169,25 +185,74 @@ std::optional<FailedCommand> failed_command_in(std::string_view output) {
     return found;
 }
 
+namespace {
+
+bool targets_msvc_abi(const FailedCommand& cmd) {
+    auto triple = mcpp::toolchain::triple::parse(cmd.target);
+    return triple && triple->os == "windows" && triple->env == "msvc";
+}
+
+// C++23 or later: `c++23`, `gnu++2b`, `c++26`, `c++2c`, `c++latest`.
+bool at_least_cxx23(std::string_view standard) {
+    auto plus = standard.find("++");
+    if (plus == std::string_view::npos) return false;
+    auto level = standard.substr(plus + 2);
+    if (level == "latest") return true;
+    if (level.size() != 2) return false;
+    if (level[0] == '2' && level[1] >= 'b' && level[1] <= 'z') return true;
+    return level >= "23" && level <= "99";
+}
+
+std::string render(Symptom symptom, const FailedCommand& cmd, const Probe& probed);
+
+} // namespace
+
 std::string advice(std::string_view output, const ProbeFn& probe) {
     const auto symptom = symptom_in(output);
     if (symptom == Symptom::None) return {};
     auto cmd = failed_command_in(output);
-    if (!cmd) return {};
-    auto triple = mcpp::toolchain::triple::parse(cmd->target);
-    if (!triple || triple->os != "windows" || triple->env != "msvc") return {};
+    if (!cmd || !targets_msvc_abi(*cmd)) return {};
+    auto probed = probe(*cmd);
+    if (!probed || probed->predefinesImplCoroutine) return {};
+    return render(symptom, *cmd, *probed);
+}
+
+std::string std_module_advice(std::string_view message, const ProbeFn& probe) {
+    std::optional<FailedCommand> cmd;
+    bool stlModule = false;
+    for_each_line(message, [&](std::string_view line) {
+        if (!line.starts_with("command: ")) return;
+        if (auto c = failed_command_in(line)) {
+            cmd = std::move(c);
+            for (auto const& w : split_words(line.substr(9)))
+                if (w.ends_with("std.ixx") || w.ends_with("std.compat.ixx")) stlModule = true;
+        }
+    });
+    if (!cmd || !stlModule || !targets_msvc_abi(*cmd) || !at_least_cxx23(cmd->standard))
+        return {};
     auto probed = probe(*cmd);
     if (!probed || probed->predefinesImplCoroutine) return {};
+    return render(Symptom::StdModuleGenerator, *cmd, *probed);
+}
 
-    const std::string compiler = probed->version.empty()
-        ? std::string("this clang") : std::format("clang {}", probed->version);
-    const std::string section = triple->str();
+std::string std_module_advice(std::string_view message) {
+    return std_module_advice(message, run_probe);
+}
+
+namespace {
+
+std::string render(Symptom symptom, const FailedCommand& cmd, const Probe& probed) {
+    auto triple = mcpp::toolchain::triple::parse(cmd.target);
+
+    const std::string compiler = probed.version.empty()
+        ? std::string("this clang") : std::format("clang {}", probed.version);
+    const std::string section = triple ? triple->str() : cmd.target;
     std::string note = std::format(
         "\n"
         "note: {} does not support C++20 coroutines on {} (this Microsoft\n"
         "      ABI): it does not predefine __cpp_impl_coroutine there, so the\n"
         "      MSVC STL's <coroutine> is empty.",
-        compiler, cmd->target);
+        compiler, cmd.target);
     if (symptom == Symptom::StdModuleGenerator) {
         note +=
             " The C++23 std module includes\n"
@@ -226,6 +291,8 @@ std::string advice(std::string_view output, const ProbeFn& probe) {
     return note;
 }
 
+} // namespace
+
 std::optional<Probe> run_probe(const FailedCommand& cmd) {
     std::error_code ec;
     const auto empty = std::filesystem::temp_directory_path(ec)

src/toolchain/stdmod.cppm

@@ -131,11 +131,12 @@ std::expected<std::string, StdModError> run_capture_command(
     return r.output;
 }
 
-// A precompile that stopped inside the STL's <generator> because the
+// A precompile of the MSVC STL's std module that cannot succeed because the
 // compiler does not support coroutines on this MSVC ABI says so after the
-// compiler's own output (mcpp.toolchain.msvc_coroutines).
+// error (mcpp.toolchain.msvc_coroutines). Decided from the command: the
+// compiler's diagnostics reach the terminal, not this message.
 StdModError with_coroutine_note(StdModError e) {
-    e.message += msvc_coroutines::advice(e.message);
+    e.message += msvc_coroutines::std_module_advice(e.message);
     return e;
 }
 

tests/unit/test_msvc_coroutines.cpp

@@ -42,6 +42,55 @@ co::ProbeFn answering(bool predefines, int* calls = nullptr) {
     };
 }
 
+// What the std module precompile's error actually carries (#781's Windows CI,
+// run 37802975713): the command, not the compiler's diagnostics, which reach
+// the terminal directly.
+constexpr std::string_view kStdModuleMessage =
+    "std module precompile failed (rc=1):\n"
+    "\n"
+    "command: C:/Users/runneradmin/.mcpp/registry\\data\\xpkgs\\xim-x-llvm\\23.1.3\\bin\\clang++.exe "
+    "-std=c++23 -fms-runtime-lib=dll -x c++-module -Wno-include-angled-in-module-purview "
+    "--target=i686-pc-windows-msvc "
+    "-Xmicrosoft-visualc-tools-root \"C:\\Program Files\\Microsoft Visual Studio\\18\\Enterprise\\VC\\Tools\\MSVC\\14.51.36231\" "
+    "--precompile \"C:\\Program Files\\Microsoft Visual Studio\\18\\Enterprise\\VC\\Tools\\MSVC\\14.51.36231\\modules\\std.ixx\" "
+    "-o std.pcm\n";
+
+std::string with_standard(std::string_view message, std::string_view from, std::string_view to) {
+    std::string s(message);
+    s.replace(s.find(from), from.size(), to);
+    return s;
+}
+
+TEST(MsvcCoroutines, StdModuleMessageWithoutDiagnosticsGetsTheNote) {
+    auto note = co::std_module_advice(kStdModuleMessage, answering(false));
+    ASSERT_FALSE(note.empty());
+    EXPECT_NE(note.find("<generator>"), std::string::npos);
+    EXPECT_NE(note.find("standard = \"c++20\""), std::string::npos);
+    EXPECT_NE(note.find("[target.i686-windows-msvc]"), std::string::npos);
+}
+
+TEST(MsvcCoroutines, StdModuleBelowCxx23IsNotThisFailure) {
+    int calls = 0;
+    auto cxx20 = with_standard(kStdModuleMessage, "-std=c++23", "-std=c++20");
+    EXPECT_TRUE(co::std_module_advice(cxx20, answering(false, &calls)).empty());
+    EXPECT_EQ(calls, 0);
+    for (auto spelling : {"-std=c++2b", "-std=c++26", "-std=gnu++23"}) {
+        auto later = with_standard(kStdModuleMessage, "-std=c++23", spelling);
+        EXPECT_FALSE(co::std_module_advice(later, answering(false)).empty()) << spelling;
+    }
+}
+
+TEST(MsvcCoroutines, StdModuleOfLibcxxIsNotThisFailure) {
+    int calls = 0;
+    auto libcxx = with_standard(kStdModuleMessage, "modules\\std.ixx", "share\\libc++\\v1\\std.cppm");
+    EXPECT_TRUE(co::std_module_advice(libcxx, answering(false, &calls)).empty());
+    EXPECT_EQ(calls, 0);
+}
+
+TEST(MsvcCoroutines, StdModuleOnACompilerThatPredefinesTheMacroGetsNoNote) {
+    EXPECT_TRUE(co::std_module_advice(kStdModuleMessage, answering(true)).empty());
+}
+
 TEST(MsvcCoroutines, StdModuleFailureIsTheGeneratorSymptom) {
     EXPECT_EQ(co::symptom_in(kStdModuleFailure), co::Symptom::StdModuleGenerator);
     auto cmd = co::failed_command_in(kStdModuleFailure);