wip: plan char+space single-append optimization

Agent-Logs-Url: https://github.com/Cpp2Rust/cpp2rust/sessions/c9bd1adc-01f6-415e-a50c-9e8a4cb1e414

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

Author: Copilot

cpp2rust/converter/converter.h

@@ -313,57 +313,52 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
 #define StrCat(...) _StrCat(__FUNCTION__, __LINE__, __VA_ARGS__)
 
-  // All-literal overload: selected (by partial ordering) when every argument
-  // is a string literal.  Merges all literals (each followed by a space) into
-  // a single buffer and performs one rs_code append instead of one per literal.
-  // e.g. StrCat("foo", "bar") is equivalent to StrCat("foo bar").
-  template <std::size_t... Ns>
-  inline void _StrCat(const char *func, int line, const char (&...vals)[Ns]) {
+  // Appends each argument to rs_code_, merging consecutive string literals
+  // into a single buffer before each append.  Non-literal arguments are
+  // appended individually.
+  // e.g. StrCat("foo", "bar", var1, "xyz") performs:
+  //   rs_code_ += "foo bar "   (one append for the merged literal run)
+  //   rs_code_ += var1 + ' '  (one append for the non-literal)
+  //   rs_code_ += "xyz "      (one append for the trailing literal)
+  template <typename... Ts>
+  inline void _StrCat(const char *func, int line, const Ts &...vals) {
     llvm::errs() << '[' << func << ':' << line << "] ";
     ((llvm::errs() << vals << '\n'), ...);
-    constexpr std::size_t total = (Ns + ...);
-    const auto merged = _MergeStrings<total>(vals...);
-    rs_code_->append(merged.data(), total);
+    _AppendRuns(*rs_code_, std::array<char, 0>{}, vals...);
   }
 
-  // General fallback: used when at least one argument is not a string literal.
-  // Each argument is appended individually (value then space).
-  template <typename... Ts>
-  inline void _StrCat(const char *func, int line, const Ts &...vals) {
-    llvm::errs() << '[' << func << ':' << line << "] ";
-    ((llvm::errs() << vals << '\n', AppendToCode(*rs_code_, vals)), ...);
+  // Base case: no more arguments.  Flush the pending literal buffer if any.
+  template <std::size_t BufSize>
+  static void _AppendRuns(std::string &rs_code, std::array<char, BufSize> buf) {
+    if constexpr (BufSize > 0)
+      rs_code.append(buf.data(), BufSize);
   }
 
-  // Merges k string literals (each followed by a space) into a single
-  // std::array<char, Total> where Total = sum(Ns).  The null terminator of
-  // each literal is dropped and replaced by a space character.
-  template <std::size_t Total, std::size_t... Ns>
-  static constexpr std::array<char, Total>
-  _MergeStrings(const char (&...strs)[Ns]) {
-    std::array<char, Total> result{};
-    std::size_t pos = 0;
-    auto fill = [&](const char *s, std::size_t n) {
-      for (std::size_t i = 0; i < n - 1; ++i)
-        result[pos++] = s[i];
-      result[pos++] = ' ';
-    };
-    (fill(strs, Ns), ...);
-    return result;
+  // Head is a string literal: extend the pending buffer (N-1 content chars
+  // followed by a space, replacing the null terminator) and recurse.
+  template <std::size_t BufSize, std::size_t N, typename... Rest>
+  static void _AppendRuns(std::string &rs_code, std::array<char, BufSize> buf,
+                          const char (&val)[N], const Rest &...rest) {
+    std::array<char, BufSize + N> new_buf;
+    for (std::size_t i = 0; i < BufSize; ++i)
+      new_buf[i] = buf[i];
+    for (std::size_t i = 0; i < N - 1; ++i)
+      new_buf[BufSize + i] = val[i];
+    new_buf[BufSize + N - 1] = ' ';
+    _AppendRuns(rs_code, new_buf, rest...);
   }
 
-  // General fallback: append val then a space (two operations).
-  template <typename T>
-  static void AppendToCode(std::string &rs_code, const T &val) {
+  // Head is NOT a string literal: flush the pending buffer (if any), append
+  // the non-literal argument (value + space), then continue with an empty
+  // buffer.
+  template <std::size_t BufSize, typename T, typename... Rest>
+  static void _AppendRuns(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);
     rs_code += val;
     rs_code += ' ';
-  }
-
-  // Specialization for a single string literal in the general (mixed) path:
-  // reuses _MergeStrings to perform one append call.
-  template <std::size_t N>
-  static void AppendToCode(std::string &rs_code, const char (&val)[N]) {
-    const auto combined = _MergeStrings<N>(val);
-    rs_code.append(combined.data(), N);
+    _AppendRuns(rs_code, std::array<char, 0>{}, rest...);
   }
 
   class Buffer {