perf: eliminate spurious string copies in cpp2rust converter

- mapper.cpp: use std::move() when passing local strings to
  normalizeTranslationRule() to avoid unnecessary copies in ToString()
- converter.cpp recordDerivesCopy: cache Mapper::Map(f->getType())
  result to avoid calling it twice per field
- converter.cpp GetDefaultAsString: cache Mapper::ToString(qual_type)
  result to avoid calling it twice in successive else-if branches
- converter.cpp EmitRustStruct/VisitCXXRecordDecl: replace
  std::string(keyword::kImpl) + ' ' + name with std::format to avoid
  constructing multiple temporary strings
- converter_lib.cpp GetFileName: construct std::filesystem::path
  directly from StringRef iterators, eliminating the intermediate
  file_name_as_string copy and reusing file_path.string() as fallback

Agent-Logs-Url: https://github.com/Cpp2Rust/cpp2rust/sessions/b538d15a-35a7-4c43-93f3-6621eabaf105

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

Author: Copilot

cpp2rust/converter/converter.cpp

@@ -552,15 +552,16 @@ static bool recordDerivesCopy(const clang::RecordDecl *decl) {
   for (auto f : decl->fields()) {
     // Records that contain std::vector, std::array, std::string or anything
     // that is translated to Vec<>, do not derive Copy
-    if (Mapper::Map(f->getType()).starts_with("Vec<")) {
+    auto mapped = Mapper::Map(f->getType());
+    if (mapped.starts_with("Vec<")) {
       return false;
     }
 
     if (IsUniquePtr(f->getType())) {
       return false;
     }
 
-    if (Mapper::Map(f->getType()).starts_with("BTreeMap<")) {
+    if (mapped.starts_with("BTreeMap<")) {
       return false;
     }
 
@@ -652,7 +653,7 @@ void Converter::EmitRustStruct(clang::RecordDecl *decl) {
     auto struct_name = GetRecordName(cxx);
 
     ConvertCXXMethodDecls(
-        cxx, std::string(keyword::kImpl) + ' ' + struct_name,
+        cxx, std::format("{} {}", keyword::kImpl, struct_name),
         [](const auto *method) {
           return !method->isImplicit() &&
                  !(method->getDefinition() &&
@@ -700,7 +701,7 @@ bool Converter::VisitCXXRecordDecl(clang::CXXRecordDecl *decl) {
   if (decl->isStruct() || decl->isClass()) {
     for (auto c : GetTemplateInstantiatedCtors(decl)) {
       if (!decl_ids_.contains(GetID(c))) {
-        StrCat(std::string(keyword::kImpl) + ' ' + GetRecordName(decl),
+        StrCat(std::format("{} {}", keyword::kImpl, GetRecordName(decl)),
                token::kOpenCurlyBracket);
         VisitCXXMethodDecl(c);
         StrCat(token::kCloseCurlyBracket);
@@ -2745,40 +2746,43 @@ std::string Converter::GetDefaultAsString(clang::QualType qual_type) {
   } else if (auto *array_type =
                  clang::dyn_cast<clang::IncompleteArrayType>(qual_type)) {
     return GetDefaultAsString(array_type->getElementType());
-  } else if (Mapper::ToString(qual_type) == "struct std::pair") {
-    auto template_args = *GetTemplateArgs(qual_type);
-    auto first_type = template_args[0].getAsType();
-    auto second_type = template_args[1].getAsType();
-    return std::format("({}, {})", GetDefaultAsString(first_type),
-                       GetDefaultAsString(second_type));
-  } else if (Mapper::ToString(qual_type).contains("std::array")) {
-    assert(GetTemplateArgs(qual_type).has_value());
-    auto template_args = *GetTemplateArgs(qual_type);
-    assert(template_args.size() == 2);
-    auto array_size = template_args[1];
-    unsigned size = 0;
-    switch (array_size.getKind()) {
-    case clang::TemplateArgument::Expression: {
-      auto array_size_expr = array_size.getAsExpr();
-      assert(array_size_expr && !array_size_expr->isValueDependent());
-      clang::Expr::EvalResult result;
-      ENSURE(array_size_expr->EvaluateAsInt(result, ctx_));
-      size = result.Val.getInt().getZExtValue();
-      break;
-    }
-    case clang::TemplateArgument::Integral: {
-      size = array_size.getAsIntegral().getZExtValue();
-      break;
-    }
-    default:
-      assert(0 && "Unsupported array size kind");
-      break;
-    }
-    return std::format(
-        "std::array::from_fn::<_, {}, _>(|_| Default::default()).to_vec()",
-        size);
   } else {
-    return GetDefaultAsStringFallback(qual_type);
+    auto qual_type_str = Mapper::ToString(qual_type);
+    if (qual_type_str == "struct std::pair") {
+      auto template_args = *GetTemplateArgs(qual_type);
+      auto first_type = template_args[0].getAsType();
+      auto second_type = template_args[1].getAsType();
+      return std::format("({}, {})", GetDefaultAsString(first_type),
+                         GetDefaultAsString(second_type));
+    } else if (qual_type_str.contains("std::array")) {
+      assert(GetTemplateArgs(qual_type).has_value());
+      auto template_args = *GetTemplateArgs(qual_type);
+      assert(template_args.size() == 2);
+      auto array_size = template_args[1];
+      unsigned size = 0;
+      switch (array_size.getKind()) {
+      case clang::TemplateArgument::Expression: {
+        auto array_size_expr = array_size.getAsExpr();
+        assert(array_size_expr && !array_size_expr->isValueDependent());
+        clang::Expr::EvalResult result;
+        ENSURE(array_size_expr->EvaluateAsInt(result, ctx_));
+        size = result.Val.getInt().getZExtValue();
+        break;
+      }
+      case clang::TemplateArgument::Integral: {
+        size = array_size.getAsIntegral().getZExtValue();
+        break;
+      }
+      default:
+        assert(0 && "Unsupported array size kind");
+        break;
+      }
+      return std::format(
+          "std::array::from_fn::<_, {}, _>(|_| Default::default()).to_vec()",
+          size);
+    } else {
+      return GetDefaultAsStringFallback(qual_type);
+    }
   }
 }
 

cpp2rust/converter/converter_lib.cpp

@@ -267,11 +267,10 @@ std::string GetFileName(const clang::Decl *decl) {
   const auto &ctx = decl->getASTContext();
   const auto full_location = ctx.getFullLoc(decl->getBeginLoc());
   const auto file_name = ctx.getSourceManager().getFilename(full_location);
-  const auto file_name_as_string = file_name.str();
-  const std::filesystem::path file_path(file_name_as_string);
+  const std::filesystem::path file_path(file_name.begin(), file_name.end());
   return std::filesystem::exists(file_path)
              ? std::filesystem::canonical(file_path).string()
-             : file_name_as_string;
+             : file_path.string();
 }
 
 unsigned GetLineNumber(const clang::Decl *decl) {

cpp2rust/converter/mapper.cpp

@@ -720,7 +720,7 @@ std::string ToString(clang::QualType qual_type) {
   std::string type;
   llvm::raw_string_ostream os(type);
   normalizeQualType(qual_type).print(os, getPrintPolicy());
-  return normalizeTranslationRule(type);
+  return normalizeTranslationRule(std::move(type));
 }
 
 std::string ToString(const clang::NamedDecl *decl) {
@@ -736,7 +736,7 @@ std::string ToString(const clang::NamedDecl *decl) {
 
   if (!func_decl) {
     decl->printQualifiedName(os, getPrintPolicy());
-    return normalizeTranslationRule(out);
+    return normalizeTranslationRule(std::move(out));
   }
 
   os << ToString(func_decl->getReturnType()) << " ";