ConfigureLog: Log try_compile and try_run checks

Add configure log events for `try_compile` and `try_run` results.

Issue: #23200

4 files changed, 141 insertions, 12 deletions

diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx
index e7351b2..25a0e2d 100644
--- a/Source/cmCoreTryCompile.cxx
+++ b/Source/cmCoreTryCompile.cxx
@@ -16,6 +16,7 @@
 #include "cmsys/FStream.hxx"
 
 #include "cmArgumentParser.h"
+#include "cmConfigureLog.h"
 #include "cmExportTryCompileFileGenerator.h"
 #include "cmGlobalGenerator.h"
 #include "cmMakefile.h"
@@ -1124,6 +1125,11 @@ cm::optional<cmTryCompileResult> cmCoreTryCompile::TryCompileCode(
   }
 
   cmTryCompileResult result;
+  result.SourceDirectory = sourceDirectory;
+  result.BinaryDirectory = this->BinaryDirectory;
+  result.Variable = *arguments.CompileResultVariable;
+  result.VariableCached = !arguments.NoCache;
+  result.Output = std::move(output);
   result.ExitCode = res;
   return result;
 }
@@ -1266,3 +1272,20 @@ std::string cmCoreTryCompile::WriteSource(std::string const& filename,
   file.close();
   return filepath;
 }
+
+void cmCoreTryCompile::WriteTryCompileEventFields(
+  cmConfigureLog& log, cmTryCompileResult const& compileResult)
+{
+#ifndef CMAKE_BOOTSTRAP
+  log.BeginObject("directories"_s);
+  log.WriteValue("source"_s, compileResult.SourceDirectory);
+  log.WriteValue("binary"_s, compileResult.BinaryDirectory);
+  log.EndObject();
+  log.BeginObject("buildResult"_s);
+  log.WriteValue("variable"_s, compileResult.Variable);
+  log.WriteValue("cached"_s, compileResult.VariableCached);
+  log.WriteLiteralTextBlock("stdout"_s, compileResult.Output);
+  log.WriteValue("exitCode"_s, compileResult.ExitCode);
+  log.EndObject();
+#endif
+}
diff --git a/Source/cmCoreTryCompile.h b/Source/cmCoreTryCompile.h
index d9649b9..6d29586 100644
--- a/Source/cmCoreTryCompile.h
+++ b/Source/cmCoreTryCompile.h
@@ -14,12 +14,20 @@
 #include "cmArgumentParserTypes.h"
 #include "cmStateTypes.h"
 
+class cmConfigureLog;
 class cmMakefile;
 template <typename Iter>
 class cmRange;
 
 struct cmTryCompileResult
 {
+  std::string SourceDirectory;
+  std::string BinaryDirectory;
+
+  bool VariableCached = true;
+  std::string Variable;
+
+  std::string Output;
   int ExitCode = 1;
 };
 
@@ -108,6 +116,9 @@ public:
    */
   void FindOutputFile(const std::string& targetName);
 
+  static void WriteTryCompileEventFields(
+    cmConfigureLog& log, cmTryCompileResult const& compileResult);
+
   std::string BinaryDirectory;
   std::string OutputFile;
   std::string FindErrorMessage;
diff --git a/Source/cmTryCompileCommand.cxx b/Source/cmTryCompileCommand.cxx
index a2c4ce1..74d240f 100644
--- a/Source/cmTryCompileCommand.cxx
+++ b/Source/cmTryCompileCommand.cxx
@@ -2,6 +2,9 @@
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmTryCompileCommand.h"
 
+#include <cm/optional>
+
+#include "cmConfigureLog.h"
 #include "cmCoreTryCompile.h"
 #include "cmExecutionStatus.h"
 #include "cmMakefile.h"
@@ -13,6 +16,19 @@
 #include "cmValue.h"
 #include "cmake.h"
 
+namespace {
+#ifndef CMAKE_BOOTSTRAP
+void WriteTryCompileEvent(cmConfigureLog& log, cmMakefile const& mf,
+                          cmTryCompileResult const& compileResult)
+{
+  log.BeginEvent("try_compile");
+  log.WriteBacktrace(mf);
+  cmCoreTryCompile::WriteTryCompileEventFields(log, compileResult);
+  log.EndEvent();
+}
+#endif
+}
+
 bool cmTryCompileCommand(std::vector<std::string> const& args,
                          cmExecutionStatus& status)
 {
@@ -59,7 +75,15 @@ bool cmTryCompileCommand(std::vector<std::string> const& args,
   if (!arguments) {
     return true;
   }
-  tc.TryCompileCode(arguments, targetType);
+
+  if (cm::optional<cmTryCompileResult> compileResult =
+        tc.TryCompileCode(arguments, targetType)) {
+#ifndef CMAKE_BOOTSTRAP
+    if (cmConfigureLog* log = mf.GetCMakeInstance()->GetConfigureLog()) {
+      WriteTryCompileEvent(*log, mf, *compileResult);
+    }
+#endif
+  }
 
   // if They specified clean then we clean up what we can
   if (tc.SrcFileSignature) {
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx
index bbefcd9..794f2c6 100644
--- a/Source/cmTryRunCommand.cxx
+++ b/Source/cmTryRunCommand.cxx
@@ -3,12 +3,15 @@
 #include "cmTryRunCommand.h"
 
 #include <cstdio>
+#include <stdexcept>
 
 #include <cm/optional>
+#include <cmext/string_view>
 
 #include "cmsys/FStream.hxx"
 
 #include "cmArgumentParserTypes.h"
+#include "cmConfigureLog.h"
 #include "cmCoreTryCompile.h"
 #include "cmDuration.h"
 #include "cmExecutionStatus.h"
@@ -23,6 +26,44 @@
 #include "cmake.h"
 
 namespace {
+struct cmTryRunResult
+{
+  bool VariableCached = true;
+  std::string Variable;
+  cm::optional<std::string> Stdout;
+  cm::optional<std::string> Stderr;
+  cm::optional<std::string> ExitCode;
+};
+
+#ifndef CMAKE_BOOTSTRAP
+void WriteTryRunEvent(cmConfigureLog& log, cmMakefile const& mf,
+                      cmTryCompileResult const& compileResult,
+                      cmTryRunResult const& runResult)
+{
+  log.BeginEvent("try_run");
+  log.WriteBacktrace(mf);
+  cmCoreTryCompile::WriteTryCompileEventFields(log, compileResult);
+
+  log.BeginObject("runResult"_s);
+  log.WriteValue("variable"_s, runResult.Variable);
+  log.WriteValue("cached"_s, runResult.VariableCached);
+  if (runResult.Stdout) {
+    log.WriteLiteralTextBlock("stdout"_s, *runResult.Stdout);
+  }
+  if (runResult.Stderr) {
+    log.WriteLiteralTextBlock("stderr"_s, *runResult.Stderr);
+  }
+  if (runResult.ExitCode) {
+    try {
+      log.WriteValue("exitCode"_s, std::stoi(*runResult.ExitCode));
+    } catch (std::invalid_argument const&) {
+      log.WriteValue("exitCode"_s, *runResult.ExitCode);
+    }
+  }
+  log.EndObject();
+  log.EndEvent();
+}
+#endif
 
 class TryRunCommandImpl : public cmCoreTryCompile
 {
@@ -96,24 +137,33 @@ bool TryRunCommandImpl::TryRunCode(std::vector<std::string> const& argv)
   }
 
   bool captureRunOutput = false;
-  bool captureRunOutputStdOut = false;
-  bool captureRunOutputStdErr = false;
   if (arguments.OutputVariable) {
     captureRunOutput = true;
   } else if (arguments.CompileOutputVariable) {
     arguments.OutputVariable = arguments.CompileOutputVariable;
   }
-  if (arguments.RunOutputStdOutVariable || arguments.RunOutputStdErrVariable) {
-    captureRunOutputStdOut = arguments.RunOutputStdOutVariable.has_value();
-    captureRunOutputStdErr = arguments.RunOutputStdErrVariable.has_value();
-  } else if (arguments.RunOutputVariable) {
-    captureRunOutput = true;
+
+  // Capture the split output for the configure log unless the caller
+  // requests combined output to be captured by a variable.
+  bool captureRunOutputStdOutErr = true;
+  if (!arguments.RunOutputStdOutVariable &&
+      !arguments.RunOutputStdErrVariable) {
+    if (arguments.RunOutputVariable) {
+      captureRunOutput = true;
+      captureRunOutputStdOutErr = false;
+    } else if (arguments.OutputVariable) {
+      captureRunOutputStdOutErr = false;
+    }
   }
 
   // do the try compile
   cm::optional<cmTryCompileResult> compileResult =
     this->TryCompileCode(arguments, cmStateEnums::EXECUTABLE);
 
+  cmTryRunResult runResult;
+  runResult.Variable = this->RunResultVariable;
+  runResult.VariableCached = !arguments.NoCache;
+
   // now try running the command if it compiled
   if (compileResult && compileResult->ExitCode == 0) {
     if (this->OutputFile.empty()) {
@@ -134,14 +184,26 @@ bool TryRunCommandImpl::TryRunCode(std::vector<std::string> const& argv)
           runArgs, *arguments.SourceDirectoryOrFile,
           *arguments.CompileResultVariable,
           captureRunOutput ? &runOutputContents : nullptr,
-          captureRunOutputStdOut ? &runOutputStdOutContents : nullptr,
-          captureRunOutputStdErr ? &runOutputStdErrContents : nullptr);
+          captureRunOutputStdOutErr ? &runOutputStdOutContents : nullptr,
+          captureRunOutputStdOutErr ? &runOutputStdErrContents : nullptr);
       } else {
         this->RunExecutable(
           runArgs, arguments.RunWorkingDirectory,
           captureRunOutput ? &runOutputContents : nullptr,
-          captureRunOutputStdOut ? &runOutputStdOutContents : nullptr,
-          captureRunOutputStdErr ? &runOutputStdErrContents : nullptr);
+          captureRunOutputStdOutErr ? &runOutputStdOutContents : nullptr,
+          captureRunOutputStdOutErr ? &runOutputStdErrContents : nullptr);
+      }
+
+      if (captureRunOutputStdOutErr) {
+        runResult.Stdout = runOutputStdOutContents;
+        runResult.Stderr = runOutputStdErrContents;
+      } else {
+        runResult.Stdout = runOutputContents;
+      }
+
+      if (cmValue ec =
+            this->Makefile->GetDefinition(this->RunResultVariable)) {
+        runResult.ExitCode = *ec;
       }
 
       // now put the output into the variables
@@ -172,6 +234,15 @@ bool TryRunCommandImpl::TryRunCode(std::vector<std::string> const& argv)
     }
   }
 
+#ifndef CMAKE_BOOTSTRAP
+  if (compileResult) {
+    cmMakefile const& mf = *(this->Makefile);
+    if (cmConfigureLog* log = mf.GetCMakeInstance()->GetConfigureLog()) {
+      WriteTryRunEvent(*log, mf, *compileResult, runResult);
+    }
+  }
+#endif
+
   // if we created a directory etc, then cleanup after ourselves
   if (!this->Makefile->GetCMakeInstance()->GetDebugTryCompile()) {
     this->CleanupFiles(this->BinaryDirectory);