Merge consecutive string literals in StrCat into a single append

Replace _MakeStringWithSpace (single-literal helper) with _MergeStrings,
a constexpr function that handles k string literals at once. Add an
all-literal overload of _StrCat (selected by partial ordering whenever
every StrCat argument is a string literal) that merges all literals into
one buffer and performs a single rs_code append call.

StrCat("foo", "bar", "xyz") is now equivalent to StrCat("foo bar xyz"):
both produce exactly one append of "foo bar xyz ".

Drop #include <utility> which was only needed by the removed
_MakeStringWithSpace/std::make_index_sequence code.

Agent-Logs-Url: https://github.com/Cpp2Rust/cpp2rust/sessions/6b9ad28e-62b4-44a3-bf1e-538e5dc148ef

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

Author: Copilot

cpp2rust/converter/converter.h

@@ -14,7 +14,6 @@
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
-#include <utility>
 #include <vector>
 
 #include "converter/lex.h"
@@ -314,19 +313,42 @@ 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]) {
+    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);
+  }
+
+  // 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)), ...);
   }
 
-  // Builds a std::array of N chars from the first N-1 chars of s followed by a
-  // space. Used by AppendToCode to combine a string literal and its trailing
-  // space into a single contiguous buffer for one append call.
-  template <std::size_t N, std::size_t... I>
-  static constexpr std::array<char, N>
-  _MakeStringWithSpace(const char (&s)[N], std::index_sequence<I...>) {
-    return {s[I]..., ' '};
+  // 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;
   }
 
   // General fallback: append val then a space (two operations).
@@ -336,14 +358,11 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     rs_code += ' ';
   }
 
-  // Specialization for string literals (const char[N]): combines the string
-  // content and a trailing space into a single contiguous buffer (using the
-  // compile-time size N to skip any strlen scan) and appends it in one call.
-  // This covers all lengths, including single-char literals such as "(".
+  // 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 =
-        _MakeStringWithSpace(val, std::make_index_sequence<N - 1>{});
+    const auto combined = _MergeStrings<N>(val);
     rs_code.append(combined.data(), N);
   }