Implement all code optimizations

Agent-Logs-Url: https://github.com/Cpp2Rust/cpp2rust/sessions/02781840-6bfd-443e-9a68-91ff30c2f21d

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

Author: Copilot

cpp2rust/converter/converter.cpp

@@ -1505,30 +1505,46 @@ void Converter::ConvertGenericCallExpr(clang::CallExpr *expr) {
                                   ? function->getNumParams()
                                   : (proto ? proto->getNumParams() : num_args);
 
+  // Pre-compute per-parameter metadata once to avoid recomputing in two loops.
+  struct ParamInfo {
+    clang::Expr *arg;
+    std::string name;
+    clang::QualType type;
+    bool has_default_value;
+  };
+  const unsigned num_params_to_bind =
+      std::min<unsigned>(num_named_params, num_args);
+  std::vector<ParamInfo> param_infos;
+  param_infos.reserve(num_params_to_bind);
+  for (unsigned i = 0; i < num_params_to_bind; ++i) {
+    ParamInfo pi;
+    pi.arg = expr->getArg(i + arg_begin);
+    pi.name = function ? function->getParamDecl(i)->getNameAsString()
+                       : ("arg" + std::to_string(i));
+    pi.type = function ? function->getParamDecl(i)->getType()
+                       : proto->getParamType(i);
+    pi.has_default_value =
+        function && function->getParamDecl(i)->hasDefaultArg();
+    param_infos.push_back(std::move(pi));
+  }
+
   // Track which args are materialized temps bound to reference params
   std::vector<std::string> temp_refs(num_args);
 
-  for (unsigned i = 0; i < num_named_params && i < num_args; ++i) {
-    auto *arg = expr->getArg(i + arg_begin);
-    std::string param_name = function
-                                 ? function->getParamDecl(i)->getNameAsString()
-                                 : ("arg" + std::to_string(i));
-    clang::QualType param_type = function ? function->getParamDecl(i)->getType()
-                                          : proto->getParamType(i);
-
+  for (unsigned i = 0; i < num_params_to_bind; ++i) {
+    auto &pi = param_infos[i];
     bool is_materialize_to_ref =
-        clang::isa<clang::MaterializeTemporaryExpr>(arg) &&
-        param_type->isLValueReferenceType();
+        clang::isa<clang::MaterializeTemporaryExpr>(pi.arg) &&
+        pi.type->isLValueReferenceType();
 
     if (is_materialize_to_ref) {
       auto [binding, ref] =
-          MaterializeTemp(std::format("_{}", param_name), param_type, arg);
+          MaterializeTemp(std::format("_{}", pi.name), pi.type, pi.arg);
       StrCat(binding);
       temp_refs[i] = std::move(ref);
-    } else if (!clang::isa<clang::MaterializeTemporaryExpr>(arg)) {
-      StrCat("let", std::format("_{}: {}", param_name, ToString(param_type)),
-             "=");
-      convert_param_ty(param_type, arg);
+    } else if (!clang::isa<clang::MaterializeTemporaryExpr>(pi.arg)) {
+      StrCat("let", std::format("_{}: {}", pi.name, ToString(pi.type)), "=");
+      convert_param_ty(pi.type, pi.arg);
       StrCat(";");
     }
   }
@@ -1541,28 +1557,19 @@ void Converter::ConvertGenericCallExpr(clang::CallExpr *expr) {
   }
   {
     PushParen call_args(*this);
-    for (unsigned i = 0; i < num_named_params && i < num_args; ++i) {
-      auto *arg = expr->getArg(i + arg_begin);
-      std::string param_name =
-          function ? function->getParamDecl(i)->getNameAsString()
-                   : ("arg" + std::to_string(i));
-      clang::QualType param_type = function
-                                       ? function->getParamDecl(i)->getType()
-                                       : proto->getParamType(i);
-      bool is_parm_with_default_value =
-          function && function->getParamDecl(i)->hasDefaultArg();
-
-      if (is_parm_with_default_value) {
+    for (unsigned i = 0; i < num_params_to_bind; ++i) {
+      auto &pi = param_infos[i];
+      if (pi.has_default_value) {
         StrCat("Some(");
       }
       if (!temp_refs[i].empty()) {
         StrCat(temp_refs[i]);
-      } else if (clang::isa<clang::MaterializeTemporaryExpr>(arg)) {
-        convert_param_ty(param_type, arg);
+      } else if (clang::isa<clang::MaterializeTemporaryExpr>(pi.arg)) {
+        convert_param_ty(pi.type, pi.arg);
       } else {
-        StrCat(std::format("_{}", param_name));
+        StrCat(std::format("_{}", pi.name));
       }
-      if (is_parm_with_default_value) {
+      if (pi.has_default_value) {
         StrCat(")");
       }
       StrCat(token::kComma);
@@ -3560,6 +3567,11 @@ std::string Converter::ConvertIRFragment(
     } else if (auto *g = std::get_if<GenericFragment>(&frag)) {
       result += Mapper::InstantiateTemplate(GetCalleeOrExpr(expr), g->name);
     } else if (auto *ph = std::get_if<PlaceholderFragment>(&frag)) {
+      // Placeholder args are single-digit only ("a0".."a9"); enforced here
+      // to match the existing matchTemplate design constraint. A static_assert
+      // is not possible because ph->arg is runtime data from parsed rules.
+      assert(ph->arg.size() == 2 && std::isdigit(static_cast<unsigned char>(ph->arg[1])) &&
+             "placeholder arg must be a single-digit index");
       auto arg_idx = static_cast<int>(ph->arg[1] - '0'); // "a0" -> 0
       assert(arg_idx < static_cast<int>(all_args.size()));
       auto *arg = all_args[arg_idx];

cpp2rust/converter/converter_lib.cpp

@@ -450,16 +450,13 @@ clang::Expr *ToAddrOf(clang::ASTContext &ctx, clang::Expr *expr) {
 
 std::vector<clang::CXXRecordDecl *>
 GetNestedStructs(const clang::CXXRecordDecl *decl) {
-  std::vector<clang::Decl *> nested_decls;
-  auto predicate = [](auto *decl) {
-    return clang::isa<clang::CXXRecordDecl>(decl) && !decl->isImplicit();
-  };
-  std::copy_if(decl->decls_begin(), decl->decls_end(),
-               std::back_inserter(nested_decls), predicate);
   std::vector<clang::CXXRecordDecl *> nested_record_decls;
-  auto op = [](auto *decl) { return clang::cast<clang::CXXRecordDecl>(decl); };
-  std::transform(nested_decls.cbegin(), nested_decls.cend(),
-                 std::back_inserter(nested_record_decls), op);
+  for (auto *d : decl->decls()) {
+    if (auto *rec = clang::dyn_cast<clang::CXXRecordDecl>(d);
+        rec && !rec->isImplicit()) {
+      nested_record_decls.push_back(rec);
+    }
+  }
   return nested_record_decls;
 }
 

cpp2rust/converter/mapper.cpp

@@ -333,9 +333,10 @@ auto parallel_search(const Map &container, MatchPred &&match_func) {
     return std::make_pair(container.cend(), std::move(hit_match));
   }
 
-  // Serial fast-path: avoids thread-pool creation overhead for small maps.
-  constexpr size_t kSerialThreshold = 16;
-  if (container.size() <= kSerialThreshold) {
+  // Parallel fast-path threshold: for small maps, skip thread-pool creation
+  // and use a simple serial scan to avoid overhead.
+  constexpr size_t kParallelThreshold = 16;
+  if (container.size() <= kParallelThreshold) {
     for (auto it = container.cbegin(); it != container.cend(); ++it) {
       auto m = match_func(it->first);
       if (!m)