Optimize unnecessary object duplication: avoid regex recompilation, string copies

Agent-Logs-Url: https://github.com/Cpp2Rust/cpp2rust/sessions/67031e6a-ec2f-4f6c-a534-ac63f300898d

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

Author: Copilot

cpp2rust/converter/converter.cpp

@@ -9,7 +9,6 @@
 #include <llvm/Support/ConvertUTF.h>
 
 #include <format>
-#include <regex>
 
 #include "compiler.h"
 #include "converter/converter_lib.h"
@@ -381,7 +380,7 @@ bool Converter::ConvertVarDeclSkipInit(clang::VarDecl *decl) {
   }
 
   if (decl->isFileVarDecl()) {
-    name = std::regex_replace(Mapper::ToString(decl), std::regex("::"), "_");
+    name = ReplaceAll(Mapper::ToString(decl), "::", "_");
     if ((decl->isExternallyDeclarable() && !decl->hasInit()) ||
         !globals_.insert(name).second) {
       return false;
@@ -2133,10 +2132,9 @@ std::string Converter::ConvertDeclRefExpr(clang::DeclRefExpr *expr) {
     return std::format("{}::{}",
                        GetRecordName(clang::dyn_cast<clang::EnumDecl>(
                            enum_constant->getDeclContext())),
-                       enum_constant->getName().str());
+                       std::string_view(enum_constant->getName()));
   } else if (IsGlobalVar(expr)) {
-    return std::regex_replace(Mapper::ToString(expr->getDecl()),
-                              std::regex("::"), "_");
+    return ReplaceAll(Mapper::ToString(expr->getDecl()), "::", "_");
   }
 
   return GetNamedDeclAsString(decl);
@@ -2610,12 +2608,12 @@ bool Converter::VisitEnumDecl(clang::EnumDecl *decl) {
   for (auto e : decl->enumerators()) {
     llvm::SmallVector<char, 32> init;
     e->getInitVal().toString(init, 10);
-    std::string init_str(init.begin(), init.end());
     if (first_enumerator) {
       StrCat("#[default]");
       first_enumerator = false;
     }
-    StrCat(std::format("{} = {},", e->getNameAsString(), init_str));
+    StrCat(std::format("{} = {},", std::string_view(e->getName()),
+                       std::string_view(init.data(), init.size())));
   }
   StrCat("}");
   return false;
@@ -2852,7 +2850,7 @@ std::string Converter::ConvertVarDefaultInit(clang::QualType qual_type) {
 
 std::string
 Converter::GetOverloadedFunctionName(const clang::FunctionDecl *decl) {
-  std::string name(decl->getNameAsString());
+  auto name = decl->getNameAsString();
 
   if (decl->getNumParams() != 0U) {
     name += '_';
@@ -2884,7 +2882,7 @@ std::string Converter::GetRecordName(const clang::NamedDecl *decl) const {
   if (auto it = inner_structs_.find(ID); it != inner_structs_.end()) {
     return it->second;
   }
-  return std::regex_replace(Mapper::ToString(decl), std::regex("::"), "_");
+  return ReplaceAll(Mapper::ToString(decl), "::", "_");
 }
 
 std::vector<const char *>

cpp2rust/converter/converter_lib.cpp

@@ -762,4 +762,13 @@ void Unwrap(std::string &s, std::string_view prefix, std::string_view suffix) {
   }
 }
 
+std::string ReplaceAll(std::string str, std::string_view from,
+                       std::string_view to) {
+  for (size_t pos = 0; (pos = str.find(from, pos)) != std::string::npos;
+       pos += to.size()) {
+    str.replace(pos, from.size(), to);
+  }
+  return str;
+}
+
 } // namespace cpp2rust

cpp2rust/converter/converter_lib.h

@@ -167,4 +167,7 @@ std::vector<clang::Stmt *> GetSwitchCaseBody(clang::CompoundStmt *body,
 
 void Unwrap(std::string &s, std::string_view prefix, std::string_view suffix);
 
+std::string ReplaceAll(std::string str, std::string_view from,
+                       std::string_view to);
+
 } // namespace cpp2rust

cpp2rust/converter/mapper.cpp

@@ -447,7 +447,7 @@ void addBuiltinTypes(Model model) {
   auto build_rust_type = [&](clang::QualType qt) {
     unsigned bits = ctx_->getTypeSize(qt);
     char sign = qt->isSignedIntegerType() ? 'i' : 'u';
-    return std::string(1, sign) + std::to_string(bits);
+    return std::format("{}{}", sign, bits);
   };
 
   // Misc
@@ -547,13 +547,14 @@ std::string mapTypeStringRecursive(const std::string &cpp_type) {
 }
 
 std::string normalizeTranslationRule(std::string rule) {
-  const std::array<std::pair<std::regex, std::string>, 2> normalization_rules{{
-      // Dettach pointer from double reference. Useful for matching translation
-      // rules.
-      {std::regex(R"(\*\&\&)"), "* &&"},
-      // Ignore constant template parameters, i.e. replace them with _.
-      {std::regex(R"(\b\d+\b)"), "_"},
-  }};
+  static const std::array<std::pair<std::regex, std::string>, 2>
+      normalization_rules{{
+          // Dettach pointer from double reference. Useful for matching
+          // translation rules.
+          {std::regex(R"(\*\&\&)"), "* &&"},
+          // Ignore constant template parameters, i.e. replace them with _.
+          {std::regex(R"(\b\d+\b)"), "_"},
+      }};
 
   for (const auto &r : normalization_rules) {
     rule = std::regex_replace(rule, r.first, r.second);
@@ -567,7 +568,7 @@ static std::string synthesizeAnonRecordName(const clang::RecordDecl *record) {
   if (auto *parent =
           clang::dyn_cast<clang::RecordDecl>(record->getDeclContext())) {
     parent_name = parent->getIdentifier()
-                      ? parent->getIdentifier()->getName().str()
+                      ? std::string(parent->getIdentifier()->getName())
                       : synthesizeAnonRecordName(parent);
     parent_name += '_';
   }
@@ -674,7 +675,7 @@ bool ParamIsPointer(const clang::Expr *expr, unsigned index) {
 
 void AddRuleForUserDefinedType(clang::NamedDecl *decl) {
   auto cpp_name = ToString(decl);
-  auto rs_name = std::regex_replace(cpp_name, std::regex("::"), "_");
+  auto rs_name = ReplaceAll(cpp_name, "::", "_");
 
   if (types_.contains(cpp_name)) {
     return;
@@ -863,10 +864,11 @@ std::string ToString(const clang::Expr *expr) {
   }
 
   if (const auto *uop = llvm::dyn_cast<clang::UnaryOperator>(expr)) {
-    std::string opcode =
-        clang::UnaryOperator::getOpcodeStr(uop->getOpcode()).str();
-    return uop->isPostfix() ? ToString(uop->getSubExpr()) + std::move(opcode)
-                            : std::move(opcode) + ToString(uop->getSubExpr());
+    auto sub = ToString(uop->getSubExpr());
+    std::string_view opcode =
+        clang::UnaryOperator::getOpcodeStr(uop->getOpcode());
+    return uop->isPostfix() ? std::format("{}{}", sub, opcode)
+                            : std::format("{}{}", opcode, sub);
   }
 
   return "Unhandled case in ToString";

cpp2rust/converter/models/converter_refcount.cpp

@@ -1754,7 +1754,7 @@ void ConverterRefCount::ConvertGenericBinaryOperator(
     clang::BinaryOperator *expr) {
   auto lhs = expr->getLHS();
   auto rhs = expr->getRHS();
-  auto opcode = expr->getOpcodeStr().str();
+  std::string_view opcode = expr->getOpcodeStr();
 
   auto lhs_vars = GetAllVars(lhs);
   auto rhs_vars = GetAllVars(rhs);

cpp2rust/converter/plugins/emplace_back.cpp

@@ -3,8 +3,6 @@
 
 #include <clang/Sema/Initialization.h>
 
-#include <regex>
-
 #include "converter/converter_lib.h"
 #include "converter/mapper.h"
 #include "converter/models/converter_refcount.h"
@@ -139,8 +137,7 @@ clang::CXXConstructExpr *buildConstructExpr(clang::CXXMemberCallExpr *call,
 void Converter::emplace_back_emit_push_open(clang::CXXMemberCallExpr *call) {
   {
     PushExprKind push(*this, ExprKind::LValue);
-    StrCat(std::regex_replace(ToString(call->getCallee()),
-                              std::regex("emplace_back"), "push"));
+    StrCat(ReplaceAll(ToString(call->getCallee()), "emplace_back", "push"));
   }
   StrCat("(");
 }