Thread llvm::raw_ostream through _AppendRuns; remove [[gnu::always_inline]]

- Remove [[gnu::always_inline]] from all _AppendRuns overloads and _ExtendBuf.
  Compile-time evaluation is now guaranteed by the template structure itself:
  BufSize and N are non-type template parameters deduced at each instantiation,
  and _ExtendBuf is constexpr, so the buffer construction is fully resolved
  by the template machinery.

- Thread llvm::raw_ostream& dbg through every _AppendRuns overload.  The
  debug stream now receives exactly the same data at exactly the same points
  as rs_code_, so the log line reflects what is actually appended rather than
  printing each raw argument piecemeal (one line per arg with a '\n').

- Each merged literal run is written to both rs_code_ and dbg in one shot
  (when the buffer is flushed).  Each non-literal token is appended/printed
  as "val ' '" in both outputs.  A single '\n' is written by _StrCat after
  the entire call chain completes.

- Remove piecemeal ((errs() << vals << '\n'), ...) fold-expression from
  _StrCat; the debug output now comes exclusively from _AppendRuns.

Agent-Logs-Url: https://github.com/Cpp2Rust/cpp2rust/sessions/9835d76c-3b8f-4869-ad66-5a66f6849cb4

Co-authored-by: nunoplopes <2998477+nunoplopes@users.noreply.github.com>

Author: Copilot

cpp2rust/converter/converter.h

@@ -322,24 +322,26 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   //   rs_code_ += val; rs_code_ += ' ';  (two appends for the non-literal)
   //   rs_code_ += "xyz "      (one append for the trailing literal)
   //
-  // All _AppendRuns overloads are marked [[gnu::always_inline]] so that Clang
-  // inlines the entire recursive chain regardless of optimisation level.  Once
-  // inlined, the compiler can constant-fold the intermediate literal buffers
-  // (which are built exclusively from compile-time data) into a single merged
-  // string constant in the binary, giving true compile-time evaluation of the
-  // buffer construction.
+  // The debug stream receives exactly the same data at the same points, so the
+  // log line reflects what is actually appended rather than piecemeal raw args.
+  // Compile-time evaluation is achieved by template parameterisation: BufSize
+  // and N are non-type template parameters deduced at each instantiation, and
+  // _ExtendBuf is constexpr, so the buffer construction is resolved by the
+  // template machinery without any compiler-specific inlining attributes.
   template <typename... Ts>
   inline void _StrCat(const char *func, int line, const Ts &...vals) {
-    llvm::errs() << '[' << func << ':' << line << "] ";
-    ((llvm::errs() << vals << '\n'), ...);
-    _AppendRuns(*rs_code_, std::array<char, 0>{}, vals...);
+    llvm::raw_ostream &dbg = llvm::errs();
+    dbg << '[' << func << ':' << line << "] ";
+    _AppendRuns(dbg, *rs_code_, std::array<char, 0>{}, vals...);
+    dbg << '\n';
   }
 
   // Compile-time helper: extend a pending literal buffer with one more literal.
-  // Marked constexpr so the compiler evaluates it at compile time whenever the
-  // arguments are constant expressions (i.e. after inlining literal-head calls).
+  // constexpr ensures the compiler evaluates this at compile time whenever the
+  // arguments are constant expressions (i.e. once the template is instantiated
+  // with the literal sizes known as non-type template parameters).
   template <std::size_t BufSize, std::size_t N>
-  [[gnu::always_inline]] static constexpr std::array<char, BufSize + N>
+  static constexpr std::array<char, BufSize + N>
   _ExtendBuf(std::array<char, BufSize> buf, const char (&val)[N]) {
     std::array<char, BufSize + N> new_buf{};
     std::copy(buf.begin(), buf.end(), new_buf.begin());
@@ -348,34 +350,42 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     return new_buf;
   }
 
-  // Base case: no more arguments.  Flush the pending literal buffer if any.
+  // Base case: no more arguments.  Flush the pending literal buffer (if any)
+  // to both rs_code and the debug stream.
   template <std::size_t BufSize>
-  [[gnu::always_inline]] static void
-  _AppendRuns(std::string &rs_code, std::array<char, BufSize> buf) {
-    if constexpr (BufSize > 0)
+  static void _AppendRuns(llvm::raw_ostream &dbg, std::string &rs_code,
+                          std::array<char, BufSize> buf) {
+    if constexpr (BufSize > 0) {
       rs_code.append(buf.data(), BufSize);
+      dbg.write(buf.data(), BufSize);
+    }
   }
 
-  // Head is a string literal: extend the pending buffer and recurse.
+  // Head is a string literal: extend the pending buffer and recurse.  The new
+  // buffer size BufSize+N is a distinct template instantiation, so the compiler
+  // knows the content dimensions entirely at compile time.
   template <std::size_t BufSize, std::size_t N, typename... Rest>
-  [[gnu::always_inline]] static void
-  _AppendRuns(std::string &rs_code, std::array<char, BufSize> buf,
-              const char (&val)[N], const Rest &...rest) {
-    _AppendRuns(rs_code, _ExtendBuf(buf, val), rest...);
+  static void _AppendRuns(llvm::raw_ostream &dbg, std::string &rs_code,
+                          std::array<char, BufSize> buf,
+                          const char (&val)[N], const Rest &...rest) {
+    _AppendRuns(dbg, rs_code, _ExtendBuf(buf, val), rest...);
   }
 
-  // Head is NOT a string literal: flush the pending buffer (if any), then
-  // append the non-literal argument followed by a space (two separate appends),
+  // Head is NOT a string literal: flush the pending buffer (if any) to both
+  // outputs, then append/print the non-literal argument followed by a space,
   // and continue with an empty buffer.
   template <std::size_t BufSize, typename T, typename... Rest>
-  [[gnu::always_inline]] static void
-  _AppendRuns(std::string &rs_code, std::array<char, BufSize> buf,
-              const T &val, const Rest &...rest) {
-    if constexpr (BufSize > 0)
+  static void _AppendRuns(llvm::raw_ostream &dbg, std::string &rs_code,
+                          std::array<char, BufSize> buf, const T &val,
+                          const Rest &...rest) {
+    if constexpr (BufSize > 0) {
       rs_code.append(buf.data(), BufSize);
+      dbg.write(buf.data(), BufSize);
+    }
     rs_code += val;
     rs_code += ' ';
-    _AppendRuns(rs_code, std::array<char, 0>{}, rest...);
+    dbg << val << ' ';
+    _AppendRuns(dbg, rs_code, std::array<char, 0>{}, rest...);
   }
 
   class Buffer {