Start/Stop trace API should print to llvm::errs() by default.

Author: vgvassilev

lib/CppInterOp/Tracing.cpp

@@ -69,9 +69,16 @@ std::string TraceInfo::writeToFile(const std::string& Version) {
   return std::string(Path);
 }
 
-std::string TraceInfo::StartRegion() {
+std::string TraceInfo::StartRegion(bool WriteOnStdErr) {
   m_RegionStart = m_Log.size();
   m_InRegion = true;
+  m_WriteOnStdErr = WriteOnStdErr;
+
+  // When streaming to stderr, skip creating a file.
+  if (WriteOnStdErr) {
+    m_RegionPath.clear();
+    return "";
+  }
 
   llvm::SmallString<128> TmpDir;
   llvm::sys::path::system_temp_directory(/*ErasedOnReboot=*/true, TmpDir);
@@ -91,13 +98,18 @@ void TraceInfo::StopRegion(const std::string& Version) {
     return;
   m_InRegion = false;
 
+  // When streaming to stderr, there is no file to write.
+  if (m_WriteOnStdErr)
+    return;
+
   std::error_code EC;
   llvm::raw_fd_ostream OS(m_RegionPath, EC);
   if (EC)
     return;
 
-  OS << "// CppInterOp trace region\n";
   std::string Ver = Version.empty() ? CppImpl::GetVersion() : Version;
+
+  OS << "// CppInterOp trace region\n";
   WriteVersionComment(OS, Ver);
   OS << "// Generated automatically.\n";
   OS << "#include <CppInterOp/CppInterOp.h>\n\n";

lib/CppInterOp/Tracing.h

@@ -102,7 +102,11 @@ class TraceInfo {
     return (it != m_HandleMap.end()) ? it->second : "nullptr";
   }
 
-  void appendToLog(const std::string& line) { m_Log.push_back(line); }
+  void appendToLog(const std::string& line) {
+    m_Log.push_back(line);
+    if (m_InRegion && m_WriteOnStdErr)
+      llvm::errs() << line << "\n";
+  }
   const std::vector<std::string>& getLog() const { return m_Log; }
   std::string getLastLogEntry() const {
     return m_Log.empty() ? "" : m_Log.back();
@@ -113,13 +117,15 @@ class TraceInfo {
   CPPINTEROP_TRACE_API std::string writeToFile(const std::string& Version = "");
 
   /// Begin a traced region. Returns the path where StopTracing will write.
-  CPPINTEROP_TRACE_API std::string StartRegion();
+  /// \param WriteOnStdErr if true, also emit the reproducer to stderr.
+  CPPINTEROP_TRACE_API std::string StartRegion(bool WriteOnStdErr = true);
 
   /// End the traced region and write only the region's entries to the file.
   CPPINTEROP_TRACE_API void StopRegion(const std::string& Version = "");
 
 private:
   std::string m_RegionPath;
+  bool m_WriteOnStdErr = false;
 
 public:
   void clear() {
@@ -146,10 +152,11 @@ CPPINTEROP_TRACE_API void InitTracing();
 
 /// Begin recording a traced region. If tracing is not yet active, activates
 /// it. Returns the path where StopTracing() will write the reproducer.
-inline std::string StartTracing() {
+/// \param WriteOnStdErr if true, also emit the reproducer to stderr on stop.
+inline std::string StartTracing(bool WriteOnStdErr = true) {
   if (!TraceInfo::TheTraceInfo)
     InitTracing();
-  return TraceInfo::TheTraceInfo->StartRegion();
+  return TraceInfo::TheTraceInfo->StartRegion(WriteOnStdErr);
 }
 
 /// End the traced region and write the reproducer file containing only the

unittests/CppInterOp/TracingTests.cpp

@@ -402,7 +402,7 @@ TEST(StartTracingActivation, ActivatesIfNotActive) {
   TraceInfo::TheTraceInfo = nullptr;
 
   // StartTracing should call InitTracing (covers line 151).
-  std::string Path = CppInterOp::Tracing::StartTracing();
+  std::string Path = CppInterOp::Tracing::StartTracing(/*WriteOnStdErr=*/false);
   ASSERT_NE(TraceInfo::TheTraceInfo, nullptr);
   ASSERT_FALSE(Path.empty());
 
@@ -711,7 +711,7 @@ static std::string ReadFileToString(const std::string& path) {
 // This test reads source files from the build tree via CPPINTEROP_DIR.
 TEST_F(TracingTest, StartStopTracingWritesToFile) {
   // StartTracing begins recording; StopTracing writes the file.
-  std::string Path = CppInterOp::Tracing::StartTracing();
+  std::string Path = CppInterOp::Tracing::StartTracing(/*WriteOnStdErr=*/false);
   ASSERT_FALSE(Path.empty());
 
   // Calls within the region are recorded.
@@ -734,7 +734,7 @@ TEST_F(TracingTest, OnlyRegionCallsAreRecorded) {
   // Calls before StartTracing should not appear.
   VoidFunc();
 
-  std::string Path = CppInterOp::Tracing::StartTracing();
+  std::string Path = CppInterOp::Tracing::StartTracing(/*WriteOnStdErr=*/false);
   ASSERT_FALSE(Path.empty());
 
   AnnotatedFunction(42);
@@ -767,7 +767,7 @@ TEST_F(TracingTest, StartTracingWithEnvVarNarrowsToRegion) {
   // This call is before the region.
   VoidFunc();
 
-  std::string Path = CppInterOp::Tracing::StartTracing();
+  std::string Path = CppInterOp::Tracing::StartTracing(/*WriteOnStdErr=*/false);
   ASSERT_FALSE(Path.empty());
 
   AnnotatedFunction(7);
@@ -786,11 +786,13 @@ TEST_F(TracingTest, StartTracingWithEnvVarNarrowsToRegion) {
 
 TEST_F(TracingTest, MultipleStartStopRegions) {
   // Multiple regions should each produce their own file.
-  std::string Path1 = CppInterOp::Tracing::StartTracing();
+  std::string Path1 =
+      CppInterOp::Tracing::StartTracing(/*WriteOnStdErr=*/false);
   AnnotatedFunction(1);
   CppInterOp::Tracing::StopTracing();
 
-  std::string Path2 = CppInterOp::Tracing::StartTracing();
+  std::string Path2 =
+      CppInterOp::Tracing::StartTracing(/*WriteOnStdErr=*/false);
   AnnotatedFunction(2);
   CppInterOp::Tracing::StopTracing();
 
@@ -810,6 +812,48 @@ TEST_F(TracingTest, MultipleStartStopRegions) {
   llvm::sys::fs::remove(Path2);
 }
 
+// ---------------------------------------------------------------------------
+// Tests: StartTracing WriteOnStdErr option
+// ---------------------------------------------------------------------------
+
+TEST_F(TracingTest, WriteOnStdErrStreamsEntriesImmediately) {
+  testing::internal::CaptureStderr();
+
+  // Default is WriteOnStdErr=true — no file is created.
+  std::string Path = CppInterOp::Tracing::StartTracing();
+  EXPECT_TRUE(Path.empty());
+
+  AnnotatedFunction(99);
+
+  // Capture stderr *before* StopTracing — the entry must already be there.
+  std::string Mid = testing::internal::GetCapturedStderr();
+  EXPECT_THAT(Mid, HasSubstr("Cpp::AnnotatedFunction(99)"))
+      << "Entry should appear on stderr immediately, not after StopTracing";
+
+  // Restart capture for the rest.
+  testing::internal::CaptureStderr();
+  VoidFunc();
+  CppInterOp::Tracing::StopTracing("test-version");
+  std::string Rest = testing::internal::GetCapturedStderr();
+  EXPECT_THAT(Rest, HasSubstr("Cpp::VoidFunc()"));
+}
+
+TEST_F(TracingTest, WriteToFileWhenStdErrDisabled) {
+  std::string Path = CppInterOp::Tracing::StartTracing(/*WriteOnStdErr=*/false);
+  ASSERT_FALSE(Path.empty());
+
+  AnnotatedFunction(77);
+
+  CppInterOp::Tracing::StopTracing();
+
+  // The file should contain the full reproducer.
+  std::string FileContent = ReadFileToString(Path);
+  EXPECT_THAT(FileContent, HasSubstr("#include <CppInterOp/CppInterOp.h>"));
+  EXPECT_THAT(FileContent, HasSubstr("Cpp::AnnotatedFunction(77)"));
+
+  llvm::sys::fs::remove(Path);
+}
+
 // ---------------------------------------------------------------------------
 // Tests: all CPPINTEROP_API functions must have INTEROP_TRACE
 // ---------------------------------------------------------------------------