edits

Author: nunoplopes

cpp2rust/converter/converter.cpp

@@ -3558,7 +3558,7 @@ std::string Converter::ConvertMappedMethodCall(
 std::string Converter::GetMappedAsString(clang::Expr *expr, clang::Expr **args,
                                          unsigned num_args,
                                          TempMaterializationCtx *ctx) {
-  auto *tgt_ir = Mapper::GetExprTgt(GetCalleeOrExpr(expr));
+  auto *tgt_ir = Mapper::GetExprRule(GetCalleeOrExpr(expr));
   if (!tgt_ir)
     return {};
 
@@ -3585,7 +3585,7 @@ std::string Converter::ConvertIRFragment(
       result += Mapper::InstantiateTemplate(GetCalleeOrExpr(expr), g->n);
     } else if (auto *ph = std::get_if<PlaceholderFragment>(&frag)) {
       auto arg_idx = ph->n;
-      assert(arg_idx < static_cast<int>(all_args.size()));
+      assert(arg_idx < all_args.size());
       auto *arg = all_args[arg_idx];
       bool is_receiver = HasReceiver(expr) && arg_idx == 0;
 

cpp2rust/converter/mapper.cpp

@@ -7,10 +7,9 @@
 #include <clang/Basic/SourceManager.h>
 #include <llvm/Support/ThreadPool.h>
 
-#include <atomic>
 #include <format>
-#include <mutex>
 #include <regex>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -25,8 +24,8 @@ clang::ASTContext *ctx_ = nullptr;
 Model model_ = Model::kUnsafe;
 bool translation_rules_loaded_ = false;
 
-std::unordered_map<std::string, TranslationRule::ExprTgt>
-    exprs_; // src -> ExprTgt
+std::unordered_multimap<std::string, TranslationRule::ExprRule>
+    exprs_; // src -> ExprRule
 std::unordered_multimap<std::string, TranslationRule::TypeRule>
     types_; // src -> TypeRule
 
@@ -64,8 +63,8 @@ void AddTypeRule(std::string src, TranslationRule::TypeRule &&rule) {
 // Example:
 //   template_str   = "std::vector<T1>::vector()"
 //   instantiated   = "std::vector<int>::vector()"
-//   result         = { {"T1", "int"} }
-std::optional<std::unordered_map<std::string, std::string>>
+//   result         = { "int" }
+std::optional<std::vector<std::string>>
 matchTemplate(const std::string &template_str,
               const std::string &instantiated) {
   auto matchLiteralAt = [&](const std::string &input_str, size_t pos,
@@ -193,7 +192,7 @@ matchTemplate(const std::string &template_str,
     return std::string::npos;
   };
 
-  std::unordered_map<std::string, std::string> captured;
+  std::vector<std::string> captured;
 
   size_t ti = 0;
   size_t si = 0;
@@ -207,7 +206,7 @@ matchTemplate(const std::string &template_str,
         tj++;
       }
 
-      std::string name = template_str.substr(ti, tj - ti);
+      size_t type_idx = std::stoi(&template_str[ti + 1]) - 1;
       ti = tj;
 
       std::string nextLit;
@@ -221,10 +220,11 @@ matchTemplate(const std::string &template_str,
       }
       nextLit = template_str.substr(ti, scan - ti);
 
-      auto [it, inserted] = captured.try_emplace(std::move(name));
-      if (!inserted) {
+      captured.resize(std::max(captured.size(), type_idx + 1));
+      auto &repl = captured[type_idx];
+      if (!repl.empty()) {
         size_t end_pos = 0;
-        if (!matchLiteralAt(instantiated, si, it->second, end_pos)) {
+        if (!matchLiteralAt(instantiated, si, repl, end_pos)) {
           return std::nullopt;
         }
         si = end_pos;
@@ -245,7 +245,7 @@ matchTemplate(const std::string &template_str,
             b--;
           }
 
-          it->second = instantiated.substr(a, b - a);
+          repl = instantiated.substr(a, b - a);
           si = k;
         } else {
           size_t a = si;
@@ -258,7 +258,7 @@ matchTemplate(const std::string &template_str,
             b--;
           }
 
-          it->second = instantiated.substr(a, b - a);
+          repl = instantiated.substr(a, b - a);
           si = instantiated.size();
         }
       }
@@ -278,7 +278,7 @@ matchTemplate(const std::string &template_str,
             std::isdigit(template_str[tj + 1])) {
           break;
         }
-        tj++;
+        ++tj;
       }
 
       std::string lit = template_str.substr(ti, tj - ti);
@@ -307,29 +307,36 @@ matchTemplate(const std::string &template_str,
 // corresponding instantiated type from `types`.
 //
 // Example:
-//   types        = { {"T1", "i32"} }
+//   types        = { {"i32"} }
 //   tgt_template = "Vec<T1>"
 //   result       = "Vec<i32>"
-std::string
-instantiateTgt(const std::unordered_map<std::string, std::string> &types,
-               const std::string &tgt_template) {
+std::string instantiateTgt(const std::vector<std::string> &types,
+                           const std::string &tgt_template) {
+  assert(types.size() <= 9);
   std::string instantiated_template = tgt_template;
-  for (const auto &[key, value] : types) {
-    std::string::size_type pos = 0;
-    while ((pos = instantiated_template.find(key, pos)) != std::string::npos) {
-      instantiated_template.replace(pos, key.length(), value);
-      pos += value.length();
+  std::string::size_type pos = 0;
+  while ((pos = instantiated_template.find('T', pos)) != std::string::npos) {
+    if (pos + 1 >= instantiated_template.size()) {
+      break;
     }
+    if (!std::isdigit(instantiated_template[pos + 1])) {
+      ++pos;
+      continue;
+    }
+    auto &repl = types.at(instantiated_template[pos + 1] - '1');
+    instantiated_template.replace(pos, 2, repl);
+    pos += repl.length();
   }
   return instantiated_template;
 }
 
-std::pair<TranslationRule::TypeRule *,
-          std::unordered_map<std::string, std::string>>
-search_type(const std::string &cpp_type) {
-  auto [it, end] = types_.equal_range(GetMapKey(cpp_type));
-  TranslationRule::TypeRule *rule = nullptr;
-  std::unordered_map<std::string, std::string> subs;
+template <typename T>
+std::pair<T *, std::vector<std::string>>
+search(std::unordered_multimap<std::string, T> &map,
+       const std::string &cpp_type) {
+  auto [it, end] = map.equal_range(GetMapKey(cpp_type));
+  T *rule = nullptr;
+  std::vector<std::string> subs;
 
   for (; it != end; ++it) {
     auto &this_rule = it->second;
@@ -346,77 +353,21 @@ search_type(const std::string &cpp_type) {
   return {rule, std::move(subs)};
 }
 
-template <class Map, class MatchPred>
-Map::const_iterator parallel_search(const Map &container,
-                                    MatchPred &&match_func) {
-  if (container.empty()) {
-    return container.cend();
-  }
-
-  auto tie_breaker = [](const std::string &a, const std::string &b) -> bool {
-    if (a.size() != b.size()) {
-      // Match more specific rules first (usually the longer ones).
-      return a.size() > b.size();
-    }
-    return a < b; // Lexicographically
-  };
-
-  const unsigned hw = std::max(1u, std::thread::hardware_concurrency());
-  const unsigned nthreads =
-      std::min<unsigned>(hw, std::max<size_t>(1, container.bucket_count()));
-
-  std::atomic<size_t> next_bucket{0};
-  std::mutex hit_mtx;
-  std::optional<typename Map::key_type> hit_key;
-
-  auto worker = [&](unsigned) {
-    while (true) {
-      size_t b = next_bucket.fetch_add(1, std::memory_order_relaxed);
-      if (b >= container.bucket_count()) {
-        break;
-      }
-
-      for (auto it = container.cbegin(b); it != container.cend(b); ++it) {
-        if (!match_func(it->first)) {
-          continue;
-        }
-
-        std::scoped_lock lk(hit_mtx);
-        if (!hit_key || tie_breaker(it->first, *hit_key)) {
-          hit_key = it->first;
-        }
-      }
-    }
-  };
-
-  {
-    llvm::DefaultThreadPool pool(
-        llvm::heavyweight_hardware_concurrency(nthreads));
-    for (unsigned t = 0; t < nthreads; ++t)
-      pool.async(worker, t);
-    pool.wait();
-  }
-
-  return hit_key ? container.find(*hit_key) : container.cend();
-}
-
-decltype(exprs_)::const_iterator search(const clang::Expr *expr) {
+TranslationRule::ExprRule *search(const clang::Expr *expr) {
   auto qualified_name = ToString(expr);
-  auto result = parallel_search(exprs_, [&](const std::string &tpl) {
-    return matchTemplate(tpl, qualified_name);
-  });
+  auto [rule, subs] = search(exprs_, qualified_name);
   llvm::errs() << "search expr " << qualified_name << ", result:\n";
-  if (result != exprs_.end()) {
-    result->second.dump();
+  if (rule) {
+    rule->dump();
   } else {
     llvm::errs() << "None\n";
   }
-  return result;
+  return rule;
 }
 
 TranslationRule::TypeRule *search(clang::QualType qual_type) {
   auto type = ToString(qual_type);
-  auto [rule, subs] = search_type(type);
+  auto [rule, subs] = search(types_, type);
   llvm::errs() << "search type " << type
                << ", result: " << (rule ? rule->type_info.type : "None")
                << '\n';
@@ -427,22 +378,16 @@ void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
   for (const auto &entry : std::filesystem::recursive_directory_iterator(dir)) {
     auto &path = entry.path();
     if (entry.is_regular_file() && path.extension() == ".cpp") {
-      auto rules = TranslationRule::Load(path, model);
-      if (rules.empty()) {
+      auto [expr_rules, type_rules] = TranslationRule::Load(path, model);
+      if (expr_rules.empty() && type_rules.empty()) {
         llvm::errs() << "No rules found in " << path << '\n';
         continue;
       }
-      for (auto &[_, rule] : rules) {
-        if (auto *expr = std::get_if<TranslationRule::ExprTgt>(&rule.tgt)) {
-          if (!exprs_.try_emplace(std::move(rule.src), std::move(*expr))
-                   .second) {
-            llvm::errs() << "Key: " << rule.src << " already exists in exprs\n";
-            assert(0);
-          }
-        } else if (auto *type =
-                       std::get_if<TranslationRule::TypeRule>(&rule.tgt)) {
-          types_.emplace(GetMapKey(rule.src), std::move(*type));
-        }
+      for (auto &[_, rule] : expr_rules) {
+        exprs_.emplace(GetMapKey(rule.src), std::move(rule));
+      }
+      for (auto &[_, rule] : type_rules) {
+        types_.emplace(GetMapKey(rule.src), std::move(rule));
       }
     }
   }
@@ -560,22 +505,23 @@ clang::QualType normalizeQualType(clang::QualType qual_type) {
 }
 
 std::string mapTypeStringRecursive(const std::string &cpp_type) {
-  auto [rule, subs] = search_type(cpp_type);
+  auto [rule, subs] = search(types_, cpp_type);
   if (!rule) {
     llvm::errs() << "cpp_type: " << cpp_type << '\n';
     assert(0 && "Type is not present in types_");
   }
-  for (auto &kv : subs) {
-    kv.second = mapTypeStringRecursive(kv.second);
+  for (auto &ty : subs) {
+    ty = mapTypeStringRecursive(ty);
   }
   return instantiateTgt(subs, rule->type_info.type);
 }
 
 std::string normalizeTranslationRule(std::string rule) {
-  const std::array<std::pair<std::regex, std::string>, 2> normalization_rules{{
-      // Detach pointer from double reference. Useful for matching translation
-      // rules.
-      {std::regex(R"(\*\&\&)"), "* &&"},
+  // Detach pointer from double reference. Useful for matching translation
+  // rules.
+  rule = ReplaceAll(rule, "(*&&)", "* &&");
+
+  const std::array<std::pair<std::regex, std::string>, 1> normalization_rules{{
       // Ignore constant template parameters, i.e. replace them with _.
       {std::regex(R"(\b\d+\b)"), "_"},
   }};
@@ -610,13 +556,10 @@ bool Contains(clang::QualType qual_type) {
   return search(qual_type) != nullptr;
 }
 
-bool Contains(const clang::Expr *expr) { return search(expr) != exprs_.end(); }
+bool Contains(const clang::Expr *expr) { return search(expr) != nullptr; }
 
-const TranslationRule::ExprTgt *GetExprTgt(const clang::Expr *expr) {
-  if (auto it = search(expr); it != exprs_.end()) {
-    return &it->second;
-  }
-  return nullptr;
+const TranslationRule::ExprRule *GetExprRule(const clang::Expr *expr) {
+  return search(expr);
 }
 
 std::string MapFunctionName(const clang::FunctionDecl *decl) {
@@ -630,22 +573,21 @@ std::string MapFunctionName(const clang::FunctionDecl *decl) {
 
 std::string InstantiateTemplate(const clang::Expr *expr, unsigned n) {
   auto text = 'T' + std::to_string(n);
-  auto it = search(expr);
-  if (it == exprs_.end()) {
+  auto [rule, subs] = search(exprs_, ToString(expr));
+  if (!rule) {
     return text;
   }
-  auto types_map = matchTemplate(it->first, ToString(expr)).value();
-  for (auto &kv : types_map) {
-    kv.second = mapTypeStringRecursive(kv.second);
+  for (auto &ty : subs) {
+    ty = mapTypeStringRecursive(ty);
   }
-  return instantiateTgt(types_map, text);
+  return instantiateTgt(subs, text);
 }
 
 std::string Map(clang::QualType qual_type) {
-  auto [rule, subs] = search_type(ToString(qual_type));
+  auto [rule, subs] = search(types_, ToString(qual_type));
   if (rule) {
-    for (auto &kv : subs) {
-      kv.second = mapTypeStringRecursive(kv.second);
+    for (auto &ty : subs) {
+      ty = mapTypeStringRecursive(ty);
     }
     return instantiateTgt(subs, rule->type_info.type);
   }
@@ -663,30 +605,24 @@ bool MapsToRefcountPointer(clang::QualType qual_type) {
 }
 
 bool ReturnsPointer(const clang::Expr *expr) {
-  if (auto it = search(expr); it != exprs_.end()) {
-    return it->second.return_type.is_pointer();
-  }
-  return false;
+  auto rule = search(expr);
+  return rule && rule->return_type.is_pointer();
 }
 
 const TranslationRule::TypeInfo &GetParamInfo(const clang::Expr *expr,
                                               unsigned index) {
-  auto name = "a" + std::to_string(index);
-  auto it = search(expr);
-  assert(it != exprs_.end() && "expression must have a translation rule");
-  auto name_it = it->second.params.find(name);
-  assert(name_it != it->second.params.end() &&
-         "placeholder arg must have a corresponding param type in IR");
-  return name_it->second;
+  auto rule = search(expr);
+  assert(rule && "expression must have a translation rule");
+  return rule->params.at(index);
 }
 
 std::string GetParamType(const clang::Expr *expr, unsigned index) {
   auto &info = GetParamInfo(expr, index);
-  auto types_map = matchTemplate(search(expr)->first, ToString(expr)).value();
-  for (auto &kv : types_map) {
-    kv.second = mapTypeStringRecursive(kv.second);
+  auto [rule, subs] = search(exprs_, ToString(expr));
+  for (auto &ty : subs) {
+    ty = mapTypeStringRecursive(ty);
   }
-  return instantiateTgt(types_map, info.type);
+  return instantiateTgt(subs, info.type);
 }
 
 bool ParamIsPointer(const clang::Expr *expr, unsigned index) {