From 9fb200b08bc586f064bf26f97a636a0ea0d0dbf5 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 19:43:33 +0100
Subject: [PATCH 01/34] Guard by standard

---
 rules/cstddef/src.cpp    | 4 ++++
 rules/iomanip/src.cpp    | 2 ++
 rules/new/src.cpp        | 2 ++
 rules/pair/src.cpp       | 2 ++
 rules/string/src.cpp     | 2 ++
 rules/unique_ptr/src.cpp | 4 ++++
 6 files changed, 16 insertions(+)

diff --git a/rules/cstddef/src.cpp b/rules/cstddef/src.cpp
index b53725844b..aa6fec4f3a 100644
--- a/rules/cstddef/src.cpp
+++ b/rules/cstddef/src.cpp
@@ -4,7 +4,9 @@
 #include <cstddef>
 #include <sys/types.h>
 
+#if __cplusplus >= 201703L
 using t1 = std::byte;
+#endif
 
 typedef size_t t2;
 typedef size_t *t3;
@@ -14,6 +16,7 @@ typedef ssize_t t6;
 typedef ssize_t *t7;
 typedef const ssize_t *t8;
 
+#if __cplusplus >= 201703L
 std::byte f1(const std::byte &a0, unsigned a1) { return operator<<(a0, a1); }
 
 std::byte f2(const std::byte &a0, unsigned a1) { return operator>>(a0, a1); }
@@ -21,3 +24,4 @@ std::byte f2(const std::byte &a0, unsigned a1) { return operator>>(a0, a1); }
 std::byte f3(std::byte &a0, unsigned a1) { return operator<<=(a0, a1); }
 
 std::byte f4(std::byte &a0, unsigned a1) { return operator>>=(a0, a1); }
+#endif
diff --git a/rules/iomanip/src.cpp b/rules/iomanip/src.cpp
index 3140233256..2a1a628ecf 100644
--- a/rules/iomanip/src.cpp
+++ b/rules/iomanip/src.cpp
@@ -3,4 +3,6 @@
 
 #include <iomanip>
 
+#if __cplusplus >= 201402L
 auto f1(int n) { return std::setw(n); }
+#endif
diff --git a/rules/new/src.cpp b/rules/new/src.cpp
index ea1a12ed09..fe9fd99ccb 100644
--- a/rules/new/src.cpp
+++ b/rules/new/src.cpp
@@ -11,4 +11,6 @@ void *f3(std::size_t a0) { return ::operator new[](a0); }
 
 void f4(void *a0) { return ::operator delete[](a0); }
 
+#if __cplusplus >= 201703L
 template <typename T1> T1 *f5(T1 *a0) { return std::launder(a0); }
+#endif
diff --git a/rules/pair/src.cpp b/rules/pair/src.cpp
index dbf2fbf50a..087cf18c4b 100644
--- a/rules/pair/src.cpp
+++ b/rules/pair/src.cpp
@@ -34,6 +34,7 @@ std::pair<T1, T2> f7(T3 &&a0, T4 &&a1) {
   return std::pair<T1, T2>(std::move(a0), std::move(a1));
 }
 
+#if __cplusplus >= 201402L
 template <class T1, class T2> auto f9(T1 &&a0, T2 &a1) {
   return std::make_pair(std::move(a0), a1);
 }
@@ -41,6 +42,7 @@ template <class T1, class T2> auto f9(T1 &&a0, T2 &a1) {
 template <class T1, class T2> auto f10(T1 &&a0, T2 &&a1) {
   return std::make_pair(std::move(a0), std::move(a1));
 }
+#endif
 
 template <typename T1, typename T2> T1 &f11(std::pair<T1, T2> &a0) {
   return a0.first;
diff --git a/rules/string/src.cpp b/rules/string/src.cpp
index 276962df85..ea6f3a3a26 100644
--- a/rules/string/src.cpp
+++ b/rules/string/src.cpp
@@ -23,7 +23,9 @@ std::string &f4(std::string &s, const char *p, std::size_t n) {
 
 const char *f5(const std::string &s) { return s.c_str(); }
 
+#if __cplusplus >= 201703L
 char *f6(std::string &s) { return s.data(); }
+#endif
 
 std::string f7(const char *s, std::size_t n) { return std::string(s, n); }
 
diff --git a/rules/unique_ptr/src.cpp b/rules/unique_ptr/src.cpp
index 8f7c5458a3..98cd44181a 100644
--- a/rules/unique_ptr/src.cpp
+++ b/rules/unique_ptr/src.cpp
@@ -9,9 +9,11 @@ template <typename T, typename A> using Init = A;
 template <typename T1> using t1 = std::unique_ptr<T1>;
 template <typename T1> using t2 = std::unique_ptr<T1[]>;
 
+#if __cplusplus >= 201402L
 template <typename T2, typename T1> std::unique_ptr<T1[]> f1(std::size_t n) {
   return std::make_unique<T1[]>(n);
 }
+#endif
 
 template <typename T1> T1 *f2(std::unique_ptr<T1> &o) { return o.get(); }
 
@@ -33,10 +35,12 @@ template <typename T1> void f6(std::unique_ptr<T1[]> &o, T1 *p) {
 
 template <typename T1> T1 *f7(std::unique_ptr<T1[]> &o) { return o.get(); }
 
+#if __cplusplus >= 201402L
 template <typename T1, typename... Args>
 std::unique_ptr<T1> f8(Init<T1, Args> &&...args) {
   return std::make_unique<T1>(std::forward<Args>(args)...);
 }
+#endif
 
 template <typename T1> void f9(std::unique_ptr<T1[]> &o) {
   return o.reset(nullptr);

From 1c351031cef1d827e15a4b50681c67ab029b2c77 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 19:45:52 +0100
Subject: [PATCH 02/34] Include rules at the end of the TU

---
 cpp2rust/CMakeLists.txt    |   1 +
 cpp2rust/cpp2rust_lib.cpp  |  40 +++++++++-
 cpp2rust/frontend_action.h |  34 +++++++++
 cpp2rust/rules_prelude.cpp | 150 +++++++++++++++++++++++++++++++++++++
 cpp2rust/rules_prelude.h   |  23 ++++++
 5 files changed, 244 insertions(+), 4 deletions(-)
 create mode 100644 cpp2rust/rules_prelude.cpp
 create mode 100644 cpp2rust/rules_prelude.h

diff --git a/cpp2rust/CMakeLists.txt b/cpp2rust/CMakeLists.txt
index 1b7825e778..d7adc64b10 100644
--- a/cpp2rust/CMakeLists.txt
+++ b/cpp2rust/CMakeLists.txt
@@ -17,6 +17,7 @@ target_compile_definitions(cpp2rust_core PUBLIC "-DCLANG_C_COMPILER=\"${CMAKE_C_
 target_compile_definitions(cpp2rust_core PUBLIC "-DCLANG_CXX_COMPILER=\"${CMAKE_CXX_COMPILER}\"")
 target_compile_definitions(cpp2rust_core PUBLIC "-DCLANG_RESOURCE_DIR=\"${LLVM_LIBRARY_DIR}/clang/${LLVM_VERSION_MAJOR}\"")
 target_compile_definitions(cpp2rust_core PUBLIC "-DCOMPAT_INCLUDE_DIR=\"${CMAKE_CURRENT_SOURCE_DIR}/compat\"")
+target_compile_definitions(cpp2rust_core PUBLIC "-DRULES_SOURCE_DIR=\"${PROJECT_SOURCE_DIR}/rules\"")
 target_compile_definitions(cpp2rust_core PUBLIC "-DRUST_STABLE_VERSION=\"${RUST_STABLE_VERSION}\"")
 
 if (APPLE)
diff --git a/cpp2rust/cpp2rust_lib.cpp b/cpp2rust/cpp2rust_lib.cpp
index 48754e5cf3..8271742d3d 100644
--- a/cpp2rust/cpp2rust_lib.cpp
+++ b/cpp2rust/cpp2rust_lib.cpp
@@ -8,11 +8,14 @@
 #include <clang/Tooling/Tooling.h>
 
 #include <filesystem>
+#include <fstream>
+#include <iterator>
 
 #include "compat/platform_flags.h"
 #include "converter/converter.h"
 #include "converter/models/converter_refcount.h"
 #include "frontend_action.h"
+#include "rules_prelude.h"
 
 namespace cpp2rust {
 std::string TranspileSrc(std::string_view cc_code, Model model,
@@ -20,17 +23,23 @@ std::string TranspileSrc(std::string_view cc_code, Model model,
                          const std::string &rules_dir,
                          std::string_view filename) {
   auto tool_args = getPlatformClangBeginFlags();
+  tool_args.push_back("-fno-spell-checking");
   tool_args.push_back("-fparse-all-comments");
   tool_args.insert(tool_args.end(), cxx_flags.begin(), cxx_flags.end());
   auto end_flags = getPlatformClangEndFlags();
   tool_args.insert(tool_args.end(), end_flags.begin(), end_flags.end());
 
+  auto language = GetRulesLanguage(filename);
+  auto code = std::string(cc_code) + GetRulesPreludeInclude(language);
+
   std::string rs_code;
   clang::tooling::runToolOnCodeWithArgs(
       std::make_unique<FrontendAction>(rs_code, model, /*first=*/true,
                                        rules_dir),
-      cc_code, tool_args, std::filesystem::path(filename).filename().string(),
-      filename.ends_with(".c") ? CLANG_C_COMPILER : CLANG_CXX_COMPILER);
+      code, tool_args, std::filesystem::path(filename).filename().string(),
+      filename.ends_with(".c") ? CLANG_C_COMPILER : CLANG_CXX_COMPILER,
+      std::make_shared<clang::PCHContainerOperations>(),
+      {{GetRulesPreludePath(language), BuildRulesPrelude(language)}});
   Converter::EmitOpaqueRecords(rs_code);
   Converter::EmitVirtualMethods(rs_code);
   if (model == Model::kRefCount) {
@@ -55,9 +64,10 @@ std::string TranspileDir(std::string_view build_dir, Model model,
   }
 
   clang::tooling::ClangTool Tool(*compile_dbase, files);
+  auto begin_flags = getPlatformClangBeginFlags();
+  begin_flags.push_back("-fno-spell-checking");
   Tool.appendArgumentsAdjuster(clang::tooling::getInsertArgumentAdjuster(
-      getPlatformClangBeginFlags(),
-      clang::tooling::ArgumentInsertPosition::BEGIN));
+      begin_flags, clang::tooling::ArgumentInsertPosition::BEGIN));
   Tool.appendArgumentsAdjuster(clang::tooling::getInsertArgumentAdjuster(
       getPlatformClangEndFlags(), clang::tooling::ArgumentInsertPosition::END));
   // Redefine __FILE__ to use just the basename, so the generated code
@@ -73,6 +83,28 @@ std::string TranspileDir(std::string_view build_dir, Model model,
         return result;
       });
 
+  std::vector<std::string> mapped;
+  mapped.reserve(2 * compile_dbase->getAllCompileCommands().size() + 4);
+  auto map = [&](std::string path, std::string content) {
+    mapped.push_back(std::move(path));
+    mapped.push_back(std::move(content));
+    Tool.mapVirtualFile(mapped[mapped.size() - 2], mapped.back());
+  };
+  for (auto language : {RulesLanguage::kC, RulesLanguage::kCxx}) {
+    map(GetRulesPreludePath(language), BuildRulesPrelude(language));
+  }
+  for (const auto &compile_command : compile_dbase->getAllCompileCommands()) {
+    std::filesystem::path path(compile_command.Filename);
+    if (path.is_relative()) {
+      path = std::filesystem::path(compile_command.Directory) / path;
+    }
+    std::ifstream file(path);
+    std::string content{std::istreambuf_iterator<char>(file),
+                        std::istreambuf_iterator<char>()};
+    map(path.string(),
+        content + GetRulesPreludeInclude(GetRulesLanguage(path.string())));
+  }
+
   std::string rs_code;
   FrontendActionFactory factory(rs_code, model, rules_dir);
   Tool.run(&factory);
diff --git a/cpp2rust/frontend_action.h b/cpp2rust/frontend_action.h
index 5aae8a0250..d018de99d5 100644
--- a/cpp2rust/frontend_action.h
+++ b/cpp2rust/frontend_action.h
@@ -6,6 +6,8 @@
 #include <clang/AST/ASTConsumer.h>
 #include <clang/Frontend/CompilerInstance.h>
 #include <clang/Frontend/FrontendAction.h>
+#include <clang/Lex/PPCallbacks.h>
+#include <clang/Lex/Preprocessor.h>
 #include <clang/Tooling/Tooling.h>
 
 #include <memory>
@@ -13,8 +15,34 @@
 
 #include "ast_consumer.h"
 #include "converter/factory.h"
+#include "rules_prelude.h"
 
 namespace cpp2rust {
+class SilenceRulesDiagnostics : public clang::PPCallbacks {
+public:
+  explicit SilenceRulesDiagnostics(clang::CompilerInstance &CI) : CI_(CI) {}
+
+  void LexedFileChanged(clang::FileID FID, LexedFileChangeReason Reason,
+                        clang::SrcMgr::CharacteristicKind FileType,
+                        clang::FileID PrevFID,
+                        clang::SourceLocation Loc) override {
+    auto &src_mgr = CI_.getSourceManager();
+    auto is_rules = [&](clang::FileID id) {
+      auto file = src_mgr.getFileEntryRefForID(id);
+      return file && IsRulesPrelude(file->getName());
+    };
+    if (Reason == LexedFileChangeReason::EnterFile && is_rules(FID)) {
+      CI_.getDiagnostics().setSuppressAllDiagnostics(true);
+    }
+    if (Reason == LexedFileChangeReason::ExitFile && is_rules(PrevFID)) {
+      CI_.getDiagnostics().setSuppressAllDiagnostics(false);
+    }
+  }
+
+private:
+  clang::CompilerInstance &CI_;
+};
+
 class FrontendAction : public clang::ASTFrontendAction {
 public:
   explicit FrontendAction(std::string &rs_code, Model model, bool first,
@@ -29,6 +57,12 @@ class FrontendAction : public clang::ASTFrontendAction {
                                          rules_dir_);
   }
 
+  bool BeginSourceFileAction(clang::CompilerInstance &CI) override {
+    CI.getPreprocessor().addPPCallbacks(
+        std::make_unique<SilenceRulesDiagnostics>(CI));
+    return true;
+  }
+
 private:
   std::string &rs_code_;
   Model model_;
diff --git a/cpp2rust/rules_prelude.cpp b/cpp2rust/rules_prelude.cpp
new file mode 100644
index 0000000000..83bc5e59e3
--- /dev/null
+++ b/cpp2rust/rules_prelude.cpp
@@ -0,0 +1,150 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include "rules_prelude.h"
+
+#include <algorithm>
+#include <cctype>
+#include <filesystem>
+#include <format>
+#include <fstream>
+#include <iterator>
+#include <set>
+#include <sstream>
+#include <vector>
+
+namespace fs = std::filesystem;
+
+namespace cpp2rust {
+
+namespace {
+
+std::string readFile(const fs::path &path) {
+  std::ifstream file(path);
+  return {std::istreambuf_iterator<char>(file),
+          std::istreambuf_iterator<char>()};
+}
+
+std::vector<std::string> splitLines(const std::string &text) {
+  std::vector<std::string> lines;
+  std::istringstream stream(text);
+  for (std::string line; std::getline(stream, line);) {
+    lines.push_back(std::move(line));
+  }
+  return lines;
+}
+
+std::string_view trimLeft(std::string_view text) {
+  while (!text.empty() && std::isspace((unsigned char)text.front())) {
+    text.remove_prefix(1);
+  }
+  return text;
+}
+
+bool isInclude(std::string_view line) {
+  line = trimLeft(line);
+  if (!line.starts_with('#')) {
+    return false;
+  }
+  return trimLeft(line.substr(1)).starts_with("include");
+}
+
+std::string withoutIncludes(const std::string &text) {
+  std::string out;
+  for (const auto &line : splitLines(text)) {
+    if (!isInclude(line)) {
+      out += line;
+    }
+    out += '\n';
+  }
+  return out;
+}
+
+std::set<std::string> getRuleNames(const std::string &text) {
+  std::set<std::string> names;
+  auto is_word = [](char c) {
+    return std::isalnum((unsigned char)c) || c == '_';
+  };
+  for (size_t i = 0; i < text.size();) {
+    if (!is_word(text[i])) {
+      ++i;
+      continue;
+    }
+    size_t end = i;
+    while (end < text.size() && is_word(text[end])) {
+      ++end;
+    }
+    std::string_view word(text.data() + i, end - i);
+    if (word.size() > 1 && (word[0] == 'f' || word[0] == 't') &&
+        std::all_of(word.begin() + 1, word.end(),
+                    [](char c) { return std::isdigit((unsigned char)c); })) {
+      names.emplace(word);
+    }
+    i = end;
+  }
+  return names;
+}
+
+void addCxxModule(std::string &out, const fs::path &module_dir) {
+  out += std::format("namespace cpp2rust_rules_{} {{\n",
+                     module_dir.filename().string());
+  out += withoutIncludes(readFile(module_dir / "src.cpp"));
+  out += "}\n";
+}
+
+void addCModule(std::string &out, const fs::path &module_dir) {
+  auto module = module_dir.filename().string();
+  auto text = readFile(module_dir / "src.c");
+  auto names = getRuleNames(text);
+  for (const auto &name : names) {
+    out += std::format("#define {} cpp2rust_rules_{}_{}\n", name, module, name);
+  }
+  out += withoutIncludes(text);
+  for (const auto &name : names) {
+    out += std::format("#undef {}\n", name);
+  }
+}
+
+} // namespace
+
+RulesLanguage GetRulesLanguage(std::string_view filename) {
+  return filename.ends_with(".c") ? RulesLanguage::kC : RulesLanguage::kCxx;
+}
+
+std::string GetRulesPreludePath(RulesLanguage language) {
+  return std::string(RULES_SOURCE_DIR) + (language == RulesLanguage::kC
+                                              ? "/cpp2rust_rules_prelude.c"
+                                              : "/cpp2rust_rules_prelude.cpp");
+}
+
+bool IsRulesPrelude(std::string_view path) {
+  return path == GetRulesPreludePath(RulesLanguage::kC) ||
+         path == GetRulesPreludePath(RulesLanguage::kCxx);
+}
+
+std::string GetRulesPreludeInclude(RulesLanguage language) {
+  return std::format("\n#include \"{}\"\n", GetRulesPreludePath(language));
+}
+
+std::string BuildRulesPrelude(RulesLanguage language) {
+  std::vector<fs::path> modules;
+  for (const auto &entry : fs::directory_iterator(RULES_SOURCE_DIR)) {
+    if (entry.is_directory()) {
+      modules.push_back(entry.path());
+    }
+  }
+  std::sort(modules.begin(), modules.end());
+
+  std::string out = "#pragma GCC system_header\n";
+  for (const auto &module_dir : modules) {
+    if (language == RulesLanguage::kCxx && fs::exists(module_dir / "src.cpp")) {
+      addCxxModule(out, module_dir);
+    }
+    if (language == RulesLanguage::kC && fs::exists(module_dir / "src.c")) {
+      addCModule(out, module_dir);
+    }
+  }
+  return out;
+}
+
+} // namespace cpp2rust
diff --git a/cpp2rust/rules_prelude.h b/cpp2rust/rules_prelude.h
new file mode 100644
index 0000000000..e4c370166c
--- /dev/null
+++ b/cpp2rust/rules_prelude.h
@@ -0,0 +1,23 @@
+#pragma once
+
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <string>
+#include <string_view>
+
+namespace cpp2rust {
+
+enum class RulesLanguage { kC, kCxx };
+
+RulesLanguage GetRulesLanguage(std::string_view filename);
+
+std::string GetRulesPreludePath(RulesLanguage language);
+
+std::string BuildRulesPrelude(RulesLanguage language);
+
+bool IsRulesPrelude(std::string_view path);
+
+std::string GetRulesPreludeInclude(RulesLanguage language);
+
+} // namespace cpp2rust

From 32200402db456675a16a742f26ad8baefb79a687 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 19:57:23 +0100
Subject: [PATCH 03/34] Load rules decls

---
 cpp2rust/ast_consumer.cpp               |   2 +
 cpp2rust/converter/rules/registry.cpp   |  26 +-
 cpp2rust/converter/rules/registry.h     |   6 +
 cpp2rust/converter/rules/rule_decls.cpp | 337 ++++++++++++++++++++++++
 cpp2rust/converter/rules/rule_decls.h   |  36 +++
 5 files changed, 403 insertions(+), 4 deletions(-)
 create mode 100644 cpp2rust/converter/rules/rule_decls.cpp
 create mode 100644 cpp2rust/converter/rules/rule_decls.h

diff --git a/cpp2rust/ast_consumer.cpp b/cpp2rust/ast_consumer.cpp
index b1611d83e9..5b225ae017 100644
--- a/cpp2rust/ast_consumer.cpp
+++ b/cpp2rust/ast_consumer.cpp
@@ -4,10 +4,12 @@
 #include "ast_consumer.h"
 
 #include "converter/converter.h"
+#include "converter/rules/rule_decls.h"
 
 namespace cpp2rust {
 void ASTConsumer::HandleTranslationUnit(clang::ASTContext &ctx) {
   auto converter = CreateConverter(rs_code_, ctx, model_, rules_dir_);
+  RuleDecls::Collect(ctx);
   converter->SetSema(CI_.getSema());
   if (first_) {
     converter->EmitFilePreamble();
diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp
index c0d048b42f..c987c17b90 100644
--- a/cpp2rust/converter/rules/registry.cpp
+++ b/cpp2rust/converter/rules/registry.cpp
@@ -23,6 +23,9 @@ bool translation_rules_loaded_ = false;
 ExprRuleMap exprs_; // key -> ExprRule
 TypeRuleMap types_; // key -> TypeRule
 
+std::unordered_map<std::string, TranslationRule::ExprRule *> exprs_by_name_;
+std::unordered_map<std::string, TranslationRule::TypeRule *> types_by_name_;
+
 void AddTypeRule(std::string src, TranslationRule::TypeRule &&rule) {
   rule.src = std::move(src);
   auto key = Matcher::Key(rule);
@@ -41,10 +44,12 @@ void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
       log() << "No rules found in " << path << '\n';
       continue;
     }
-    for (auto &[_, rule] : expr_rules) {
-      exprs_.emplace(Matcher::Key(rule), std::move(rule));
+    auto module = path.filename().string();
+    for (auto &[name, rule] : expr_rules) {
+      auto it = exprs_.emplace(Matcher::Key(rule), std::move(rule));
+      exprs_by_name_[module + '/' + name] = &it->second;
     }
-    for (auto &[_, rule] : type_rules) {
+    for (auto &[name, rule] : type_rules) {
       auto key = Matcher::Key(rule);
       auto [begin, end] = types_.equal_range(key);
       for (auto it = begin; it != end; ++it) {
@@ -56,7 +61,8 @@ void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
           std::exit(EXIT_FAILURE);
         }
       }
-      types_.emplace(std::move(key), std::move(rule));
+      auto it = types_.emplace(std::move(key), std::move(rule));
+      types_by_name_[module + '/' + name] = &it->second;
     }
   }
 }
@@ -70,6 +76,18 @@ GetParamInfo(clang::ASTContext &ctx, const clang::Expr *expr, unsigned index) {
 
 } // namespace
 
+TranslationRule::ExprRule *FindExprRule(const std::string &module,
+                                        const std::string &name) {
+  auto it = exprs_by_name_.find(module + '/' + name);
+  return it == exprs_by_name_.end() ? nullptr : it->second;
+}
+
+TranslationRule::TypeRule *FindTypeRule(const std::string &module,
+                                        const std::string &name) {
+  auto it = types_by_name_.find(module + '/' + name);
+  return it == types_by_name_.end() ? nullptr : it->second;
+}
+
 std::ranges::subrange<ExprRuleMap::iterator>
 ExprCandidates(const std::string &key) {
   auto [begin, end] = exprs_.equal_range(key);
diff --git a/cpp2rust/converter/rules/registry.h b/cpp2rust/converter/rules/registry.h
index aaa65d03b1..ce01beb506 100644
--- a/cpp2rust/converter/rules/registry.h
+++ b/cpp2rust/converter/rules/registry.h
@@ -28,6 +28,12 @@ ExprCandidates(const std::string &key);
 std::ranges::subrange<TypeRuleMap::iterator>
 TypeCandidates(const std::string &key);
 
+TranslationRule::ExprRule *FindExprRule(const std::string &module,
+                                        const std::string &name);
+
+TranslationRule::TypeRule *FindTypeRule(const std::string &module,
+                                        const std::string &name);
+
 Matcher::Match<TranslationRule::ExprRule> Search(clang::ASTContext &ctx,
                                                  const clang::Expr *expr);
 Matcher::Match<TranslationRule::TypeRule> Search(clang::ASTContext &ctx,
diff --git a/cpp2rust/converter/rules/rule_decls.cpp b/cpp2rust/converter/rules/rule_decls.cpp
new file mode 100644
index 0000000000..9bf69f4ae3
--- /dev/null
+++ b/cpp2rust/converter/rules/rule_decls.cpp
@@ -0,0 +1,337 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include "converter/rules/rule_decls.h"
+
+#include <clang/AST/DeclCXX.h>
+#include <clang/AST/DeclTemplate.h>
+#include <clang/AST/ExprCXX.h>
+#include <clang/Basic/OperatorKinds.h>
+#include <clang/Basic/SourceManager.h>
+#include <clang/Lex/Lexer.h>
+
+#include <algorithm>
+#include <cctype>
+#include <optional>
+#include <string_view>
+
+#include "converter/rules/registry.h"
+#include "logging.h"
+#include "rules_prelude.h"
+
+namespace cpp2rust::RuleDecls {
+
+namespace {
+
+constexpr std::string_view kPrefix = "cpp2rust_rules_";
+
+ExprRuleDeclMap exprs_;
+TypeRuleDeclMap types_;
+
+bool isRuleName(std::string_view name, char kind) {
+  return name.size() > 1 && name[0] == kind &&
+         std::all_of(name.begin() + 1, name.end(),
+                     [](char c) { return std::isdigit((unsigned char)c); });
+}
+
+struct RuleId {
+  std::string module;
+  std::string name;
+};
+
+std::optional<RuleId> getRuleId(const clang::NamedDecl *decl) {
+  if (!decl->getIdentifier()) {
+    return std::nullopt;
+  }
+  std::string_view name = decl->getName();
+  if (const auto *ns =
+          llvm::dyn_cast<clang::NamespaceDecl>(decl->getDeclContext())) {
+    std::string_view module = ns->getIdentifier() ? ns->getName() : "";
+    if (!module.starts_with(kPrefix)) {
+      return std::nullopt;
+    }
+    return RuleId{std::string(module.substr(kPrefix.size())),
+                  std::string(name)};
+  }
+  if (!name.starts_with(kPrefix)) {
+    return std::nullopt;
+  }
+  name.remove_prefix(kPrefix.size());
+  auto split = name.rfind('_');
+  if (split == std::string_view::npos) {
+    return std::nullopt;
+  }
+  return RuleId{std::string(name.substr(0, split)),
+                std::string(name.substr(split + 1))};
+}
+
+const clang::Expr *getReturned(const clang::FunctionDecl *decl) {
+  const auto *body =
+      llvm::dyn_cast_or_null<clang::CompoundStmt>(decl->getBody());
+  if (!body || body->size() != 1) {
+    return nullptr;
+  }
+  const auto *ret = llvm::dyn_cast<clang::ReturnStmt>(*body->body_begin());
+  return ret ? ret->getRetValue() : nullptr;
+}
+
+std::string getOperatorKey(clang::OverloadedOperatorKind op) {
+  if (op == clang::OO_None) {
+    return {};
+  }
+  return std::string("operator") + clang::getOperatorSpelling(op);
+}
+
+std::string getNameKey(clang::DeclarationName name) {
+  switch (name.getNameKind()) {
+  case clang::DeclarationName::Identifier:
+    if (const auto *identifier = name.getAsIdentifierInfo()) {
+      return identifier->getName().str();
+    }
+    return {};
+  case clang::DeclarationName::CXXOperatorName:
+    return getOperatorKey(name.getCXXOverloadedOperator());
+  default:
+    return {};
+  }
+}
+
+std::string getTypeKey(clang::QualType type) {
+  type = type.getNonReferenceType();
+  if (const auto *tst = type->getAs<clang::TemplateSpecializationType>()) {
+    if (const auto *tmpl = tst->getTemplateName().getAsTemplateDecl()) {
+      return getNameKey(tmpl->getDeclName());
+    }
+  }
+  if (const auto *tag = type->getAsTagDecl()) {
+    return getNameKey(tag->getDeclName());
+  }
+  return {};
+}
+
+const clang::Expr *skipImplicit(const clang::Expr *expr) {
+  while (true) {
+    expr = expr->IgnoreParens();
+    if (const auto *full = llvm::dyn_cast<clang::FullExpr>(expr)) {
+      expr = full->getSubExpr();
+      continue;
+    }
+    if (const auto *temporary =
+            llvm::dyn_cast<clang::MaterializeTemporaryExpr>(expr)) {
+      expr = temporary->getSubExpr();
+      continue;
+    }
+    if (const auto *bind = llvm::dyn_cast<clang::CXXBindTemporaryExpr>(expr)) {
+      expr = bind->getSubExpr();
+      continue;
+    }
+    const auto *cast = llvm::dyn_cast<clang::ImplicitCastExpr>(expr);
+    if (!cast) {
+      return expr;
+    }
+    expr = cast->getSubExpr();
+    if (cast->getCastKind() != clang::CK_UserDefinedConversion) {
+      continue;
+    }
+    if (const auto *conversion =
+            llvm::dyn_cast<clang::CXXMemberCallExpr>(expr->IgnoreImplicit())) {
+      expr = conversion->getImplicitObjectArgument();
+    }
+  }
+}
+
+bool isDeclaredByRules(clang::ASTContext &ctx, const clang::Decl *decl) {
+  auto &src_mgr = ctx.getSourceManager();
+  return IsRulesPrelude(src_mgr.getFilename(
+      src_mgr.getSpellingLoc(decl->getCanonicalDecl()->getLocation())));
+}
+
+bool refersToUndeclared(const clang::Expr *expr) {
+  expr = skipImplicit(expr);
+  if (const auto *call = llvm::dyn_cast<clang::CallExpr>(expr)) {
+    if (const auto *lookup = llvm::dyn_cast<clang::UnresolvedLookupExpr>(
+            call->getCallee()->IgnoreParenImpCasts())) {
+      return lookup->getNumDecls() == 0;
+    }
+    if (const auto *callee = call->getDirectCallee()) {
+      return callee->isImplicit() && !callee->getBuiltinID();
+    }
+  }
+  return false;
+}
+
+bool refersToUndeclared(clang::ASTContext &ctx, clang::QualType type) {
+  while (type->isPointerType() || type->isReferenceType()) {
+    type = type->getPointeeType();
+  }
+  const auto *tag = type->getAsTagDecl();
+  return tag && isDeclaredByRules(ctx, tag);
+}
+
+std::string getExprKey(clang::ASTContext &ctx, const clang::Expr *expr) {
+  expr = skipImplicit(expr);
+
+  if (llvm::isa<clang::IntegerLiteral>(expr) &&
+      expr->getBeginLoc().isMacroID()) {
+    return clang::Lexer::getImmediateMacroName(
+               expr->getBeginLoc(), ctx.getSourceManager(), ctx.getLangOpts())
+        .str();
+  }
+  if (const auto *op = llvm::dyn_cast<clang::CXXOperatorCallExpr>(expr)) {
+    return getOperatorKey(op->getOperator());
+  }
+  if (const auto *rewritten =
+          llvm::dyn_cast<clang::CXXRewrittenBinaryOperator>(expr)) {
+    return getOperatorKey(
+        clang::BinaryOperator::getOverloadedOperator(rewritten->getOperator()));
+  }
+  if (const auto *call = llvm::dyn_cast<clang::CallExpr>(expr)) {
+    const auto *callee = call->getCallee()->IgnoreParenImpCasts();
+    if (const auto *ref = llvm::dyn_cast<clang::DeclRefExpr>(callee);
+        ref && llvm::isa<clang::ParmVarDecl>(ref->getDecl())) {
+      return getOperatorKey(clang::OO_Call);
+    }
+    return getExprKey(ctx, callee);
+  }
+  if (const auto *overload = llvm::dyn_cast<clang::OverloadExpr>(expr)) {
+    return getNameKey(overload->getName());
+  }
+  if (const auto *member =
+          llvm::dyn_cast<clang::CXXDependentScopeMemberExpr>(expr)) {
+    return getNameKey(member->getMember());
+  }
+  if (const auto *ref =
+          llvm::dyn_cast<clang::DependentScopeDeclRefExpr>(expr)) {
+    return getNameKey(ref->getDeclName());
+  }
+  if (const auto *member = llvm::dyn_cast<clang::MemberExpr>(expr)) {
+    return getNameKey(member->getMemberDecl()->getDeclName());
+  }
+  if (const auto *ref = llvm::dyn_cast<clang::DeclRefExpr>(expr)) {
+    return getNameKey(ref->getDecl()->getDeclName());
+  }
+  if (const auto *unary = llvm::dyn_cast<clang::UnaryOperator>(expr)) {
+    if (unary->getSubExpr()->isTypeDependent()) {
+      return getOperatorKey(
+          clang::UnaryOperator::getOverloadedOperator(unary->getOpcode()));
+    }
+    return getExprKey(ctx, unary->getSubExpr());
+  }
+  if (const auto *binary = llvm::dyn_cast<clang::BinaryOperator>(expr)) {
+    return getOperatorKey(
+        clang::BinaryOperator::getOverloadedOperator(binary->getOpcode()));
+  }
+  if (llvm::isa<clang::ArraySubscriptExpr>(expr)) {
+    return getOperatorKey(clang::OO_Subscript);
+  }
+  if (const auto *construct =
+          llvm::dyn_cast<clang::CXXUnresolvedConstructExpr>(expr)) {
+    return getTypeKey(construct->getTypeAsWritten());
+  }
+  if (const auto *construct = llvm::dyn_cast<clang::CXXConstructExpr>(expr)) {
+    return getNameKey(construct->getConstructor()->getParent()->getDeclName());
+  }
+  if (const auto *cast = llvm::dyn_cast<clang::ExplicitCastExpr>(expr)) {
+    return getTypeKey(cast->getTypeAsWritten());
+  }
+  return {};
+}
+
+void addExprRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
+  auto id = getRuleId(decl);
+  if (!id || !isRuleName(id->name, 'f')) {
+    return;
+  }
+  const clang::FunctionDecl *function = nullptr;
+  if (const auto *tmpl = llvm::dyn_cast<clang::FunctionTemplateDecl>(decl)) {
+    function = tmpl->getTemplatedDecl();
+  } else {
+    function = llvm::dyn_cast<clang::FunctionDecl>(decl);
+  }
+  if (!function || !function->isThisDeclarationADefinition()) {
+    return;
+  }
+  const auto *returned = getReturned(function);
+  if (decl->isInvalidDecl() || function->isInvalidDecl() || !returned ||
+      returned->containsErrors() || refersToUndeclared(returned)) {
+    log() << "rule " << id->module << "::" << id->name << " does not apply\n";
+    return;
+  }
+  auto *rule = RuleRegistry::FindExprRule(id->module, id->name);
+  if (!rule) {
+    log() << "rule " << id->module << "::" << id->name << " has no target\n";
+    return;
+  }
+  auto key = getExprKey(ctx, returned);
+  log() << "rule " << id->module << "::" << id->name << " -> '" << key << "'\n";
+  exprs_.emplace(std::move(key), ExprRuleDecl{function, rule});
+}
+
+void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
+  auto id = getRuleId(decl);
+  if (!id || !isRuleName(id->name, 't')) {
+    return;
+  }
+  const clang::TypedefNameDecl *alias = nullptr;
+  if (const auto *tmpl = llvm::dyn_cast<clang::TypeAliasTemplateDecl>(decl)) {
+    alias = tmpl->getTemplatedDecl();
+  } else {
+    alias = llvm::dyn_cast<clang::TypedefNameDecl>(decl);
+  }
+  if (!alias) {
+    return;
+  }
+  if (decl->isInvalidDecl() || alias->isInvalidDecl() ||
+      alias->getUnderlyingType()->containsErrors() ||
+      refersToUndeclared(ctx, alias->getUnderlyingType())) {
+    log() << "rule " << id->module << "::" << id->name << " does not apply\n";
+    return;
+  }
+  auto *rule = RuleRegistry::FindTypeRule(id->module, id->name);
+  if (!rule) {
+    log() << "rule " << id->module << "::" << id->name << " has no target\n";
+    return;
+  }
+  auto key = getTypeKey(alias->getUnderlyingType());
+  log() << "rule " << id->module << "::" << id->name << " -> '" << key << "'\n";
+  types_.emplace(std::move(key), TypeRuleDecl{decl, rule});
+}
+
+void addRules(clang::ASTContext &ctx, const clang::DeclContext *context) {
+  for (const auto *child : context->decls()) {
+    if (const auto *ns = llvm::dyn_cast<clang::NamespaceDecl>(child)) {
+      if (ns->getIdentifier() && ns->getName().starts_with(kPrefix)) {
+        addRules(ctx, ns);
+      }
+      continue;
+    }
+    if (const auto *named = llvm::dyn_cast<clang::NamedDecl>(child)) {
+      addExprRule(ctx, named);
+      addTypeRule(ctx, named);
+    }
+  }
+}
+
+} // namespace
+
+void Collect(clang::ASTContext &ctx) {
+  exprs_.clear();
+  types_.clear();
+  addRules(ctx, ctx.getTranslationUnitDecl());
+  log() << "collected " << exprs_.size() << " expression rules and "
+        << types_.size() << " type rules\n";
+}
+
+std::ranges::subrange<ExprRuleDeclMap::iterator>
+ExprCandidates(const std::string &key) {
+  auto [begin, end] = exprs_.equal_range(key);
+  return {begin, end};
+}
+
+std::ranges::subrange<TypeRuleDeclMap::iterator>
+TypeCandidates(const std::string &key) {
+  auto [begin, end] = types_.equal_range(key);
+  return {begin, end};
+}
+
+} // namespace cpp2rust::RuleDecls
diff --git a/cpp2rust/converter/rules/rule_decls.h b/cpp2rust/converter/rules/rule_decls.h
new file mode 100644
index 0000000000..12f8eaa483
--- /dev/null
+++ b/cpp2rust/converter/rules/rule_decls.h
@@ -0,0 +1,36 @@
+#pragma once
+
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <clang/AST/ASTContext.h>
+#include <clang/AST/Decl.h>
+
+#include <ranges>
+#include <string>
+#include <unordered_map>
+
+#include "converter/translation_rule.h"
+
+namespace cpp2rust::RuleDecls {
+struct ExprRuleDecl {
+  const clang::FunctionDecl *decl;
+  TranslationRule::ExprRule *rule;
+};
+
+struct TypeRuleDecl {
+  const clang::NamedDecl *decl;
+  TranslationRule::TypeRule *rule;
+};
+
+using ExprRuleDeclMap = std::unordered_multimap<std::string, ExprRuleDecl>;
+using TypeRuleDeclMap = std::unordered_multimap<std::string, TypeRuleDecl>;
+
+void Collect(clang::ASTContext &ctx);
+
+std::ranges::subrange<ExprRuleDeclMap::iterator>
+ExprCandidates(const std::string &key);
+
+std::ranges::subrange<TypeRuleDeclMap::iterator>
+TypeCandidates(const std::string &key);
+} // namespace cpp2rust::RuleDecls

From dd8eb3482b66adad5c2907321485e197c8a4adac Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:33:47 +0100
Subject: [PATCH 04/34] Update rules

---
 rules/algorithm/src.cpp   |  17 ++--
 rules/brotli/src.c        |  11 +++
 rules/builtin_types/src.c |  30 ++++++
 rules/cstddef/src.c       |   6 ++
 rules/cstddef/src.cpp     |   2 +
 rules/dirent/src.c        |   7 ++
 rules/fcntl/src.c         |   8 ++
 rules/ioctl/src.c         |   6 ++
 rules/map/src.cpp         | 108 +++++++++++++++-----
 rules/pair/src.cpp        |   2 +-
 rules/select/src.c        |   6 ++
 rules/stdio/src.c         |   8 ++
 rules/unique_ptr/src.cpp  |   2 +-
 rules/vector/src.cpp      | 202 ++++++++++++++++++++++++++------------
 14 files changed, 321 insertions(+), 94 deletions(-)
 create mode 100644 rules/brotli/src.c
 create mode 100644 rules/builtin_types/src.c
 create mode 100644 rules/cstddef/src.c
 create mode 100644 rules/dirent/src.c
 create mode 100644 rules/fcntl/src.c
 create mode 100644 rules/ioctl/src.c
 create mode 100644 rules/select/src.c
 create mode 100644 rules/stdio/src.c

diff --git a/rules/algorithm/src.cpp b/rules/algorithm/src.cpp
index 620934b32d..bad063e693 100644
--- a/rules/algorithm/src.cpp
+++ b/rules/algorithm/src.cpp
@@ -5,6 +5,7 @@
 #include <fstream>
 #include <iterator>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 template <typename T1> void f1(T1 first, T1 last) {
@@ -30,15 +31,19 @@ template <typename T1> T1 *f8(T1 *first, T1 *last) {
 
 template <typename T1> void f9(T1 &a0, T1 &a1) { return std::swap(a0, a1); }
 
-template <typename T1>
-typename std::vector<T1>::iterator f10(typename std::vector<T1>::iterator a0,
-                                       typename std::vector<T1>::iterator a1) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+typename std::vector<T1>::iterator f10(It a0, It a1) {
   return std::unique(a0, a1);
 }
 
-template <typename T1, typename T2>
-void f12(typename std::vector<T1>::iterator a0,
-         typename std::vector<T1>::iterator a1, const T2 &a2) {
+template <typename It, typename T2,
+          typename T1 = typename std::iterator_traits<It>::value_type,
+          typename = typename std::enable_if<std::is_same<
+              It, typename std::vector<T1>::iterator>::value>::type>
+void f12(It a0, It a1, const T2 &a2) {
   return std::fill(a0, a1, a2);
 }
 
diff --git a/rules/brotli/src.c b/rules/brotli/src.c
new file mode 100644
index 0000000000..2ec73213db
--- /dev/null
+++ b/rules/brotli/src.c
@@ -0,0 +1,11 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include "brotli/decode.h"
+#include "brotli/encode.h"
+
+typedef BrotliDecoderResult t1;
+typedef BrotliEncoderMode t2;
+typedef BrotliDecoderStateStruct *t3;
+typedef const BrotliDecoderStateStruct *t4;
+typedef BrotliDecoderErrorCode t5;
diff --git a/rules/builtin_types/src.c b/rules/builtin_types/src.c
new file mode 100644
index 0000000000..680e1de594
--- /dev/null
+++ b/rules/builtin_types/src.c
@@ -0,0 +1,30 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#define BUILTIN_TYPE(T, N0, N1, N2, N3, N4)                                    \
+  typedef T N0;                                                                \
+  typedef T *N1;                                                               \
+  typedef const T *N2;                                                         \
+  typedef volatile T *N3;                                                      \
+  typedef const volatile T *N4;
+
+BUILTIN_TYPE(_Bool, t10, t11, t12, t13, t14)
+BUILTIN_TYPE(char, t20, t21, t22, t23, t24)
+BUILTIN_TYPE(signed char, t30, t31, t32, t33, t34)
+BUILTIN_TYPE(unsigned char, t40, t41, t42, t43, t44)
+BUILTIN_TYPE(short, t60, t61, t62, t63, t64)
+BUILTIN_TYPE(unsigned short, t70, t71, t72, t73, t74)
+BUILTIN_TYPE(int, t90, t91, t92, t93, t94)
+BUILTIN_TYPE(unsigned int, t100, t101, t102, t103, t104)
+BUILTIN_TYPE(float, t130, t131, t132, t133, t134)
+BUILTIN_TYPE(long, t140, t141, t142, t143, t144)
+BUILTIN_TYPE(unsigned long, t150, t151, t152, t153, t154)
+BUILTIN_TYPE(long long, t160, t161, t162, t163, t164)
+BUILTIN_TYPE(unsigned long long, t170, t171, t172, t173, t174)
+BUILTIN_TYPE(double, t180, t181, t182, t183, t184)
+BUILTIN_TYPE(long double, t190, t191, t192, t193, t194)
+BUILTIN_TYPE(__int128, t200, t201, t202, t203, t204)
+BUILTIN_TYPE(unsigned __int128, t210, t211, t212, t213, t214)
+BUILTIN_TYPE(void, t220, t221, t222, t223, t224)
+
+#undef BUILTIN_TYPE
diff --git a/rules/cstddef/src.c b/rules/cstddef/src.c
new file mode 100644
index 0000000000..700633384a
--- /dev/null
+++ b/rules/cstddef/src.c
@@ -0,0 +1,6 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <stddef.h>
+
+typedef __typeof__(sizeof(0)) t5;
diff --git a/rules/cstddef/src.cpp b/rules/cstddef/src.cpp
index aa6fec4f3a..848f12befb 100644
--- a/rules/cstddef/src.cpp
+++ b/rules/cstddef/src.cpp
@@ -8,6 +8,8 @@
 using t1 = std::byte;
 #endif
 
+using std::size_t;
+
 typedef size_t t2;
 typedef size_t *t3;
 typedef const size_t *t4;
diff --git a/rules/dirent/src.c b/rules/dirent/src.c
new file mode 100644
index 0000000000..7a78c99c15
--- /dev/null
+++ b/rules/dirent/src.c
@@ -0,0 +1,7 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <dirent.h>
+
+typedef DIR *t1;
+typedef struct dirent t2;
diff --git a/rules/fcntl/src.c b/rules/fcntl/src.c
new file mode 100644
index 0000000000..4a8eaa66c7
--- /dev/null
+++ b/rules/fcntl/src.c
@@ -0,0 +1,8 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <fcntl.h>
+
+int (*f1)(int, int, ...) = fcntl;
+
+int (*f2)(const char *, int, ...) = open;
diff --git a/rules/ioctl/src.c b/rules/ioctl/src.c
new file mode 100644
index 0000000000..fe322aec32
--- /dev/null
+++ b/rules/ioctl/src.c
@@ -0,0 +1,6 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <sys/ioctl.h>
+
+int (*f1)(int, unsigned long, ...) = ioctl;
diff --git a/rules/map/src.cpp b/rules/map/src.cpp
index 121a140511..1a81480c01 100644
--- a/rules/map/src.cpp
+++ b/rules/map/src.cpp
@@ -1,16 +1,30 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#include <iterator>
 #include <map>
+#include <type_traits>
 #include <utility>
 
 template <typename T1, typename T2> using t1 = std::map<T1, T2>;
 
-template <typename T1, typename T2>
-using t2 = typename std::map<T1, T2>::const_iterator;
-
-template <typename T1, typename T2>
-using t3 = typename std::map<T1, T2>::iterator;
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<std::is_same<
+        It, typename std::map<T1, T2>::const_iterator>::value>::type>
+void t2(It *);
+
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::map<T1, T2>::iterator>::value>::type>
+void t3(It *);
 
 template <typename T1, typename T2> T2 &f1(std::map<T1, T2> &o, const T1 &key) {
   return o.operator[](key);
@@ -53,9 +67,14 @@ typename std::map<T1, T2>::iterator f10(std::map<T1, T2> &o, const T1 &key) {
   return o.find(key);
 }
 
-template <typename T1, typename T2>
-bool f11(typename std::map<T1, T2>::iterator a,
-         typename std::map<T1, T2>::iterator b) {
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::map<T1, T2>::iterator>::value>::type>
+bool f11(It a, It b) {
   return operator!=(a, b);
 }
 
@@ -64,9 +83,14 @@ typename std::map<T1, T2>::iterator f12(std::map<T1, T2> &o) {
   return o.begin();
 }
 
-template <typename T1, typename T2>
-bool f13(typename std::map<T1, T2>::const_iterator a,
-         typename std::map<T1, T2>::const_iterator b) {
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<std::is_same<
+        It, typename std::map<T1, T2>::const_iterator>::value>::type>
+bool f13(It a, It b) {
   return operator==(a, b);
 }
 
@@ -80,9 +104,14 @@ const T2 &f15(const std::map<T1, T2> &o, const T1 &key) {
   return o.at(key);
 }
 
-template <typename T1, typename T2>
-bool f16(typename std::map<T1, T2>::iterator a,
-         typename std::map<T1, T2>::iterator b) {
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::map<T1, T2>::iterator>::value>::type>
+bool f16(It a, It b) {
   return operator==(a, b);
 }
 
@@ -92,29 +121,58 @@ typename std::map<T1, T2>::const_iterator f17(const std::map<T1, T2> &o,
   return o.find(key);
 }
 
-template <typename T1, typename T2>
-typename std::map<T1, T2>::const_iterator
-f19(const typename std::map<T1, T2>::iterator &it) {
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::map<T1, T2>::iterator>::value>::type>
+typename std::map<T1, T2>::const_iterator f19(const It &it) {
   return typename std::map<T1, T2>::const_iterator(it);
 }
 
-template <typename T1, typename T2>
-const T1 &f20(typename std::map<T1, T2>::const_iterator it) {
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<std::is_same<
+        It, typename std::map<T1, T2>::const_iterator>::value>::type>
+const T1 &f20(It it) {
   return it->first;
 }
 
-template <typename T1, typename T2>
-const T2 &f21(typename std::map<T1, T2>::const_iterator it) {
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<std::is_same<
+        It, typename std::map<T1, T2>::const_iterator>::value>::type>
+const T2 &f21(It it) {
   return it->second;
 }
 
-template <typename T1, typename T2>
-const T1 &f22(typename std::map<T1, T2>::iterator it) {
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::map<T1, T2>::iterator>::value>::type>
+const T1 &f22(It it) {
   return it->first;
 }
 
-template <typename T1, typename T2>
-T2 &f23(typename std::map<T1, T2>::iterator it) {
+template <
+    typename It,
+    typename T1 = typename std::remove_const<
+        typename std::iterator_traits<It>::value_type::first_type>::type,
+    typename T2 = typename std::iterator_traits<It>::value_type::second_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::map<T1, T2>::iterator>::value>::type>
+T2 &f23(It it) {
   return it->second;
 }
 
diff --git a/rules/pair/src.cpp b/rules/pair/src.cpp
index 087cf18c4b..c72845700c 100644
--- a/rules/pair/src.cpp
+++ b/rules/pair/src.cpp
@@ -31,7 +31,7 @@ std::pair<T1, T2> f6(T3 &a0, T4 &a1) {
 
 template <typename T1, typename T2, typename T3, typename T4>
 std::pair<T1, T2> f7(T3 &&a0, T4 &&a1) {
-  return std::pair<T1, T2>(std::move(a0), std::move(a1));
+  return std::pair<T1, T2>(std::forward<T3>(a0), std::forward<T4>(a1));
 }
 
 #if __cplusplus >= 201402L
diff --git a/rules/select/src.c b/rules/select/src.c
new file mode 100644
index 0000000000..0c711faf92
--- /dev/null
+++ b/rules/select/src.c
@@ -0,0 +1,6 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <sys/select.h>
+
+typedef fd_set t1;
diff --git a/rules/stdio/src.c b/rules/stdio/src.c
new file mode 100644
index 0000000000..df294843dd
--- /dev/null
+++ b/rules/stdio/src.c
@@ -0,0 +1,8 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <stdio.h>
+
+typedef FILE *t1;
+
+int (*f21)(char *, size_t, const char *, ...) = snprintf;
diff --git a/rules/unique_ptr/src.cpp b/rules/unique_ptr/src.cpp
index 98cd44181a..c25e56274f 100644
--- a/rules/unique_ptr/src.cpp
+++ b/rules/unique_ptr/src.cpp
@@ -10,7 +10,7 @@ template <typename T1> using t1 = std::unique_ptr<T1>;
 template <typename T1> using t2 = std::unique_ptr<T1[]>;
 
 #if __cplusplus >= 201402L
-template <typename T2, typename T1> std::unique_ptr<T1[]> f1(std::size_t n) {
+template <typename T1> std::unique_ptr<T1[]> f1(std::size_t n) {
   return std::make_unique<T1[]>(n);
 }
 #endif
diff --git a/rules/vector/src.cpp b/rules/vector/src.cpp
index 0121a7e316..5439b60cc1 100644
--- a/rules/vector/src.cpp
+++ b/rules/vector/src.cpp
@@ -3,23 +3,42 @@
 
 #include <algorithm>
 #include <initializer_list>
+#include <iterator>
+#include <type_traits>
 #include <vector>
 
 template <typename T, typename A> using Init = A;
 
 template <typename T1> using t1 = std::vector<T1>;
-template <typename T1> using t2 = typename std::vector<T1>::iterator;
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+void t2(It *);
 template <typename T1> using t3 = std::vector<std::vector<T1>>;
-template <typename T1> using t4 = typename std::vector<T1>::const_iterator;
+template <typename It,
+
+          typename T1 = typename std::iterator_traits<It>::value_type,
+          typename = typename std::enable_if<std::is_same<
+              It, typename std::vector<T1>::const_iterator>::value>::type>
+void t4(It *);
 
 template <typename T1, typename T2 = std::allocator<T1>>
 using t5 = std::vector<T1, T2>;
 
 #if defined(__linux__)
-template <typename T1, typename T2 = std::allocator<T1>>
-using t6 = typename std::vector<T1, T2>::iterator;
-template <typename T1, typename T2 = std::allocator<T1>>
-using t7 = typename std::vector<T1, T2>::const_iterator;
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
+void t6(Iterator<Pointer, std::vector<T1, T2>> *);
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::const_iterator>::value>::type>
+void t7(Iterator<Pointer, std::vector<T1, T2>> *);
 #endif
 
 template <typename T1>
@@ -101,44 +120,59 @@ template <typename T1> void f21(std::vector<T1> &o, const T1 &value) {
   return o.push_back(value);
 }
 
-template <typename T1>
-typename std::vector<T1>::reference f22(typename std::vector<T1>::iterator it) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+typename std::vector<T1>::reference f22(It it) {
   return it.operator*();
 }
 
-template <typename T1>
-typename std::vector<T1>::iterator
-f23(const typename std::vector<T1>::iterator &it) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+typename std::vector<T1>::iterator f23(const It &it) {
   return typename std::vector<T1>::iterator(it);
 }
 
-template <typename T1>
-typename std::vector<T1>::const_iterator
-f24(const typename std::vector<T1>::iterator &it) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+typename std::vector<T1>::const_iterator f24(const It &it) {
   return typename std::vector<T1>::const_iterator(it);
 }
 
-template <typename T1>
-typename std::vector<T1>::iterator f25(typename std::vector<T1>::iterator it,
-                                       std::size_t n) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+typename std::vector<T1>::iterator f25(It it, std::size_t n) {
   return it.operator+(n);
 }
 
-template <typename T1>
-bool f26(const typename std::vector<T1>::iterator &it1,
-         const typename std::vector<T1>::iterator &it2) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+bool f26(const It &it1, const It &it2) {
   return operator!=(it1, it2);
 }
 
-template <typename T1>
-bool f27(const typename std::vector<T1>::iterator &it1,
-         const typename std::vector<T1>::iterator &it2) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+bool f27(const It &it1, const It &it2) {
   return operator==(it1, it2);
 }
 
-template <typename T1>
-typename std::vector<T1>::iterator f28(typename std::vector<T1>::iterator a0,
-                                       int a1) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+typename std::vector<T1>::iterator f28(It a0, int a1) {
   return a0.operator++(a1);
 }
 
@@ -161,16 +195,20 @@ void f32(std::vector<std::vector<T1>> &o, std::size_t n) {
   return o.resize(n);
 }
 
-template <typename T1>
-typename std::vector<T1>::iterator::difference_type
-f33(const typename std::vector<T1>::iterator &it1,
-    const typename std::vector<T1>::iterator &it2) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+typename std::vector<T1>::iterator::difference_type f33(const It &it1,
+                                                        const It &it2) {
   return operator-(it1, it2);
 }
 
-template <typename T1>
-typename std::vector<T1>::iterator &
-f34(typename std::vector<T1>::iterator &it) {
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_same<It, typename std::vector<T1>::iterator>::value>::type>
+typename std::vector<T1>::iterator &f34(It &it) {
   return it.operator++();
 }
 
@@ -199,10 +237,12 @@ template <typename T1> const T1 *f41(const std::vector<T1> &o) {
   return o.data();
 }
 
-template <typename T1>
-typename std::vector<T1>::const_iterator
-f42(typename std::vector<T1>::const_iterator first,
-    typename std::vector<T1>::const_iterator last) {
+template <typename It,
+
+          typename T1 = typename std::iterator_traits<It>::value_type,
+          typename = typename std::enable_if<std::is_same<
+              It, typename std::vector<T1>::const_iterator>::value>::type>
+typename std::vector<T1>::const_iterator f42(It first, It last) {
   return std::max_element(first, last);
 }
 
@@ -382,58 +422,94 @@ void f80(std::vector<T1, T2> &o, const T1 &value) {
   return o.push_back(value);
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
 typename std::vector<T1, T2>::reference
-f81(typename std::vector<T1, T2>::iterator it) {
+f81(Iterator<Pointer, std::vector<T1, T2>> it) {
   return it.operator*();
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
 typename std::vector<T1, T2>::iterator
-f82(const typename std::vector<T1, T2>::iterator &it) {
+f82(const Iterator<Pointer, std::vector<T1, T2>> &it) {
   return typename std::vector<T1, T2>::iterator(it);
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
 typename std::vector<T1, T2>::const_iterator
-f83(const typename std::vector<T1, T2>::iterator &it) {
+f83(const Iterator<Pointer, std::vector<T1, T2>> &it) {
   return typename std::vector<T1, T2>::const_iterator(it);
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
 typename std::vector<T1, T2>::iterator
-f84(typename std::vector<T1, T2>::iterator it, std::size_t n) {
+f84(Iterator<Pointer, std::vector<T1, T2>> it, std::size_t n) {
   return it.operator+(n);
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
-bool f85(const typename std::vector<T1, T2>::iterator &it1,
-         const typename std::vector<T1, T2>::iterator &it2) {
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
+bool f85(const Iterator<Pointer, std::vector<T1, T2>> &it1,
+         const Iterator<Pointer, std::vector<T1, T2>> &it2) {
   return operator!=(it1, it2);
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
-bool f86(const typename std::vector<T1, T2>::iterator &it1,
-         const typename std::vector<T1, T2>::iterator &it2) {
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
+bool f86(const Iterator<Pointer, std::vector<T1, T2>> &it1,
+         const Iterator<Pointer, std::vector<T1, T2>> &it2) {
   return operator==(it1, it2);
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
 typename std::vector<T1, T2>::iterator
-f87(typename std::vector<T1, T2>::iterator a0, int a1) {
+f87(Iterator<Pointer, std::vector<T1, T2>> a0, int a1) {
   return a0.operator++(a1);
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
 typename std::vector<T1, T2>::iterator::difference_type
-f88(const typename std::vector<T1, T2>::iterator &it1,
-    const typename std::vector<T1, T2>::iterator &it2) {
+f88(const Iterator<Pointer, std::vector<T1, T2>> &it1,
+    const Iterator<Pointer, std::vector<T1, T2>> &it2) {
   return operator-(it1, it2);
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::iterator>::value>::type>
 typename std::vector<T1, T2>::iterator &
-f89(typename std::vector<T1, T2>::iterator &it) {
+f89(Iterator<Pointer, std::vector<T1, T2>> &it) {
   return it.operator++();
 }
 
@@ -457,10 +533,14 @@ const T1 *f93(const std::vector<T1, T2> &o) {
   return o.data();
 }
 
-template <typename T1, typename T2 = std::allocator<T1>>
+template <template <typename...> class Iterator, typename Pointer, typename T1,
+          typename T2,
+          typename = typename std::enable_if<std::is_same<
+              Iterator<Pointer, std::vector<T1, T2>>,
+              typename std::vector<T1, T2>::const_iterator>::value>::type>
 typename std::vector<T1, T2>::const_iterator
-f94(typename std::vector<T1, T2>::const_iterator first,
-    typename std::vector<T1, T2>::const_iterator last) {
+f94(Iterator<Pointer, std::vector<T1, T2>> first,
+    Iterator<Pointer, std::vector<T1, T2>> last) {
   return std::max_element(first, last);
 }
 

From 8b5f41a7642900fa67211533b88ff9e57581bcb7 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:35:52 +0100
Subject: [PATCH 05/34] Delete string matcher and cpp-rule-preprocessor

---
 CMakeLists.txt                              |   22 -
 cpp2rust/CMakeLists.txt                     |    4 -
 cpp2rust/converter/rules/string_matcher.cpp |  396 -------
 cpp2rust/cpp_rule_preprocessor.cpp          | 1132 -------------------
 4 files changed, 1554 deletions(-)
 delete mode 100644 cpp2rust/converter/rules/string_matcher.cpp
 delete mode 100644 cpp2rust/cpp_rule_preprocessor.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index cf4cf7a501..fb2cc02976 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -215,7 +215,6 @@ add_custom_command(
 )
 
 file(GLOB rule_subdirs CONFIGURE_DEPENDS ${PROJECT_SOURCE_DIR}/rules/*)
-set(cpp_rules_ir_outputs)
 set(rust_rules_ir_outputs)
 foreach(_rule_dir IN LISTS rule_subdirs)
   file(GLOB _cpp_srcs ${_rule_dir}/src.c ${_rule_dir}/src.cpp)
@@ -224,25 +223,6 @@ foreach(_rule_dir IN LISTS rule_subdirs)
   endif()
   get_filename_component(_rule_name ${_rule_dir} NAME)
   set(_out_dir ${RULES_IR_DIR}/${_rule_name})
-  set(_cpp_out ${_out_dir}/ir_src.json)
-  set(_cxxflags)
-  set(_cxxflags_file)
-  if(EXISTS ${_rule_dir}/cxxflags)
-    set(_cxxflags_file ${_rule_dir}/cxxflags)
-    file(STRINGS ${_cxxflags_file} _flags)
-    foreach(_flag IN LISTS _flags)
-      list(APPEND _cxxflags --cxxflags=${_flag})
-    endforeach()
-  endif()
-  add_custom_command(
-    OUTPUT ${_cpp_out}
-    COMMAND ${CMAKE_COMMAND} -E make_directory ${_out_dir}
-    COMMAND $<TARGET_FILE:cpp-rule-preprocessor> --dir ${_rule_dir} --out ${_cpp_out} ${_cxxflags}
-    DEPENDS ${_cpp_srcs} ${_cxxflags_file} ${PROJECT_SOURCE_DIR}/cpp2rust/cpp_rule_preprocessor.cpp ${RUSTLS_HEADER} ${BROTLI_HEADERS}
-    VERBATIM
-  )
-  list(APPEND cpp_rules_ir_outputs ${_cpp_out})
-
   set(_rust_srcs)
   set(_rust_out)
   if(EXISTS ${_rule_dir}/tgt_unsafe.rs)
@@ -271,8 +251,6 @@ foreach(_rule_dir IN LISTS rule_subdirs)
   list(APPEND rust_rules_ir_outputs ${_rust_out})
 endforeach()
 
-add_custom_target("preprocess-cpp-rules" ALL DEPENDS ${cpp_rules_ir_outputs})
-
 add_custom_target("preprocess-rust-rules" ALL
                   DEPENDS ${rust_rules_ir_outputs})
 
diff --git a/cpp2rust/CMakeLists.txt b/cpp2rust/CMakeLists.txt
index d7adc64b10..f0389dcdf5 100644
--- a/cpp2rust/CMakeLists.txt
+++ b/cpp2rust/CMakeLists.txt
@@ -1,7 +1,6 @@
 file(GLOB_RECURSE CORE_SOURCES "*.cpp")
 list(REMOVE_ITEM CORE_SOURCES
     "${CMAKE_CURRENT_SOURCE_DIR}/cpp2rust.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/cpp_rule_preprocessor.cpp"
 )
 
 add_library(cpp2rust_core STATIC ${CORE_SOURCES})
@@ -34,6 +33,3 @@ target_link_libraries(cpp2rust_core PUBLIC ${llvm_libs})
 
 add_clang_executable(cpp2rust PARTIAL_SOURCES_INTENDED cpp2rust.cpp)
 target_link_libraries(cpp2rust PRIVATE cpp2rust_core)
-
-add_clang_executable(cpp-rule-preprocessor PARTIAL_SOURCES_INTENDED cpp_rule_preprocessor.cpp)
-target_link_libraries(cpp-rule-preprocessor PRIVATE cpp2rust_core)
diff --git a/cpp2rust/converter/rules/string_matcher.cpp b/cpp2rust/converter/rules/string_matcher.cpp
deleted file mode 100644
index 66cc3b9809..0000000000
--- a/cpp2rust/converter/rules/string_matcher.cpp
+++ /dev/null
@@ -1,396 +0,0 @@
-// Copyright (c) 2022-present INESC-ID.
-// Distributed under the MIT license that can be found in the LICENSE file.
-
-#include <algorithm>
-#include <cassert>
-#include <cctype>
-#include <string_view>
-
-#include "converter/converter_lib.h"
-#include "converter/printer.h"
-#include "converter/rules/matcher.h"
-#include "converter/rules/registry.h"
-
-namespace cpp2rust::Matcher {
-
-namespace {
-
-// Attempts to unify an instantiated C++ type or function signature with a
-// corresponding template pattern. If the two match structurally, it returns
-// a mapping from template parameter names (e.g., "T1") to their concrete
-// instantiated types (e.g., "int"). If no match is possible, returns nullopt.
-//
-// Example:
-//   template_str   = "std::vector<T1>::vector()"
-//   instantiated   = "std::vector<int>::vector()"
-//   result         = { "int" }
-std::optional<Bindings> matchTemplate(const std::string &template_str,
-                                      const std::string &instantiated) {
-  auto matchLiteralAt = [&](const std::string &input_str, size_t pos,
-                            std::string_view literal, size_t &end_pos) -> bool {
-    size_t i = pos;
-    size_t j = 0;
-
-    while (true) {
-      while (i < input_str.size() && std::isspace(input_str[i])) {
-        i++;
-      }
-
-      while (j < literal.size() && std::isspace(literal[j])) {
-        j++;
-      }
-
-      if (j == literal.size()) {
-        end_pos = i;
-        return true;
-      }
-
-      if (i >= input_str.size()) {
-        return false;
-      }
-
-      if (input_str[i] != literal[j]) {
-        return false;
-      }
-
-      i++;
-      j++;
-    }
-  };
-
-  auto findNextLiteralSameDepth = [&](const std::string &s, size_t start,
-                                      std::string_view lit) -> size_t {
-    int ang = 0;
-    int par = 0;
-    int sq = 0;
-
-    for (size_t i = 0; i < s.size() && i < start; i++) {
-      switch (s[i]) {
-      case '<': {
-        ang++;
-        break;
-      }
-      case '>': {
-        ang--;
-        break;
-      }
-      case '(': {
-        par++;
-        break;
-      }
-      case ')': {
-        par--;
-        break;
-      }
-      case '[': {
-        sq++;
-        break;
-      }
-      case ']': {
-        sq--;
-        break;
-      }
-      default:
-        break;
-      }
-      assert(ang >= 0 && par >= 0 && sq >= 0 && "Unbalanced ang, par or sq");
-    }
-
-    int base_ang = ang;
-    int base_par = par;
-    int base_sq = sq;
-
-    for (size_t i = start; i <= s.size(); i++) {
-      if (ang == base_ang && par == base_par && sq == base_sq) {
-        size_t end_i = 0;
-        if (matchLiteralAt(s, i, lit, end_i)) {
-          return i;
-        }
-      }
-
-      if (i == s.size()) {
-        break;
-      }
-
-      char c = s[i];
-      switch (c) {
-      case '<': {
-        ang++;
-        break;
-      }
-      case '>': {
-        ang--;
-        break;
-      }
-      case '(': {
-        par++;
-        break;
-      }
-      case ')': {
-        par--;
-        break;
-      }
-      case '[': {
-        sq++;
-        break;
-      }
-      case ']': {
-        sq--;
-        break;
-      }
-      default:
-        break;
-      }
-
-      if (ang < 0 || par < 0 || sq < 0) {
-        return std::string::npos;
-      }
-    }
-
-    return std::string::npos;
-  };
-
-  Bindings captured;
-
-  size_t ti = 0;
-  size_t si = 0;
-
-  while (ti < template_str.size()) {
-    if (template_str[ti] == 'T' && ti + 1 < template_str.size() &&
-        std::isdigit(template_str[ti + 1])) {
-      size_t tj = ti + 2;
-      while (tj < template_str.size() && std::isdigit(template_str[tj])) {
-        tj++;
-      }
-
-      size_t type_idx = std::stoi(&template_str[ti + 1]) - 1;
-      assert(type_idx < TranslationRule::kMaxGenerics &&
-             "template placeholder exceeds kMaxGenerics");
-      ti = tj;
-
-      std::string_view nextLit;
-      size_t scan = ti;
-      while (scan < template_str.size()) {
-        if (template_str[scan] == 'T' && scan + 1 < template_str.size() &&
-            std::isdigit(template_str[scan + 1])) {
-          break;
-        }
-        scan++;
-      }
-      nextLit = std::string_view(template_str).substr(ti, scan - ti);
-
-      captured.resize(std::max(captured.size(), type_idx + 1));
-      auto &repl = captured[type_idx];
-      if (repl.has_value()) {
-        size_t end_pos = 0;
-        if (!matchLiteralAt(instantiated, si, *repl, end_pos)) {
-          return std::nullopt;
-        }
-        si = end_pos;
-      } else {
-        if (!nextLit.empty()) {
-          size_t k = findNextLiteralSameDepth(instantiated, si, nextLit);
-          if (k == std::string::npos) {
-            return std::nullopt;
-          }
-
-          size_t a = si;
-          size_t b = k;
-
-          while (a < b && std::isspace(instantiated[a])) {
-            a++;
-          }
-          while (b > a && std::isspace(instantiated[b - 1])) {
-            b--;
-          }
-
-          repl = instantiated.substr(a, b - a);
-          si = k;
-        } else {
-          size_t a = si;
-          size_t b = instantiated.size();
-
-          while (a < b && std::isspace(instantiated[a])) {
-            a++;
-          }
-          while (b > a && std::isspace(instantiated[b - 1])) {
-            b--;
-          }
-
-          repl = instantiated.substr(a, b - a);
-          si = instantiated.size();
-        }
-      }
-
-      if (!nextLit.empty()) {
-        size_t end_pos = 0;
-        if (!matchLiteralAt(instantiated, si, nextLit, end_pos)) {
-          return std::nullopt;
-        }
-        si = end_pos;
-        ti += nextLit.size();
-      }
-    } else {
-      size_t tj = ti;
-      while (tj < template_str.size()) {
-        if (template_str[tj] == 'T' && tj + 1 < template_str.size() &&
-            std::isdigit(template_str[tj + 1])) {
-          break;
-        }
-        ++tj;
-      }
-
-      auto lit = std::string_view(template_str).substr(ti, tj - ti);
-      size_t end_pos = 0;
-      if (!matchLiteralAt(instantiated, si, lit, end_pos)) {
-        return std::nullopt;
-      }
-      si = end_pos;
-      ti = tj;
-    }
-  }
-
-  while (si < instantiated.size() && std::isspace(instantiated[si])) {
-    si++;
-  }
-
-  if (si != instantiated.size()) {
-    return std::nullopt;
-  }
-
-  return captured;
-}
-
-std::string exprKey(const std::string &str) {
-  // Extract the function name from something like
-  // const T1 & std::foo<T1, T2>::fn_name(args)
-  auto n = str.find_first_of('(');
-  if (n == std::string::npos) {
-    n = str.size();
-  }
-
-  // Walk backwards from '(' tracking <> depth:
-  // - skip characters inside template arguments (depth > 0)
-  // - stop at the first space outside all angle brackets
-  std::string result;
-  int depth = 0;
-  for (int i = (int)n - 1; i >= 0; --i) {
-    char c = str[i];
-    if (c == '>')
-      ++depth;
-    else if (c == '<')
-      --depth;
-    else if (c == ' ' && depth == 0)
-      break;
-    else if (depth == 0)
-      result += c;
-  }
-  std::reverse(result.begin(), result.end());
-  return result;
-}
-
-std::string typeKey(const std::string &str) {
-  auto n = str.find_first_of("<[");
-  if (n == std::string::npos || str[n] == '<') {
-    return str.substr(0, n);
-  }
-  // something like int[][] or T1[] -> []
-  return str.substr(n + 1);
-}
-
-template <typename Rule, typename Candidates>
-Match<Rule> search(Candidates candidates, const std::string &txt) {
-  Rule *rule = nullptr;
-  Bindings subs;
-
-  for (auto &[_, this_rule] : candidates) {
-    auto this_subs = matchTemplate(this_rule.src, txt);
-    if (!this_subs) {
-      continue;
-    }
-    // tie breaker: prefer more specific rules (usually the longer ones)
-    if (!rule || this_rule.src.size() > rule->src.size()) {
-      rule = &this_rule;
-      subs = *std::move(this_subs);
-    }
-  }
-  return {rule, std::move(subs)};
-}
-
-Match<TranslationRule::ExprRule> searchExpr(const std::string &txt) {
-  return search<TranslationRule::ExprRule>(
-      RuleRegistry::ExprCandidates(exprKey(txt)), txt);
-}
-
-Match<TranslationRule::TypeRule> searchType(const std::string &txt) {
-  return search<TranslationRule::TypeRule>(
-      RuleRegistry::TypeCandidates(typeKey(txt)), txt);
-}
-
-std::string mapTypeString(const std::string &cpp_type) {
-  auto [rule, subs] = searchType(cpp_type);
-  if (!rule) {
-    llvm::errs() << "cpp_type: " << cpp_type << '\n';
-    assert(0 && "Type is not present in the registry");
-  }
-  for (auto &ty : subs) {
-    if (ty) {
-      ty = mapTypeString(*ty);
-    }
-  }
-  return InstantiateTgt(subs, rule->type_info.type);
-}
-
-} // namespace
-
-std::string Key(const TranslationRule::ExprRule &rule) {
-  return exprKey(rule.src);
-}
-
-std::string Key(const TranslationRule::TypeRule &rule) {
-  return typeKey(rule.src);
-}
-
-Match<TranslationRule::ExprRule> Find(clang::ASTContext &ctx,
-                                      const clang::Expr *expr) {
-  auto qualified_name = Printer::ToString(ctx, expr);
-  auto res = searchExpr(qualified_name);
-  log() << "search expr " << qualified_name << ", result:\n";
-  if (res.first) {
-    res.first->dump();
-  } else {
-    log() << "None\n";
-  }
-  return res;
-}
-
-Match<TranslationRule::TypeRule> Find(clang::ASTContext &ctx,
-                                      clang::QualType type) {
-  auto sugared = Printer::ToString(ctx, type, Printer::ScalarSugar::kPreserve);
-  if (auto res = searchType(sugared); res.first) {
-    log() << "search type " << sugared
-          << ", result: " << res.first->type_info.type << '\n';
-    return res;
-  }
-  auto desugared = Printer::ToString(ctx, type);
-  if (desugared == sugared) {
-    log() << "search type " << desugared << ", result: None\n";
-    return {};
-  }
-  auto res = searchType(desugared);
-  log() << "search type " << desugared
-        << ", result: " << (res.first ? res.first->type_info.type : "None")
-        << '\n';
-  return res;
-}
-
-bool HasRuleNamed(clang::ASTContext &ctx, const clang::FunctionDecl *decl) {
-  return !RuleRegistry::ExprCandidates(exprKey(Printer::ToString(ctx, decl)))
-              .empty();
-}
-
-std::string MapBinding(const Bindings &bindings, unsigned n) {
-  return mapTypeString(bindings.at(n).value());
-}
-
-} // namespace cpp2rust::Matcher
diff --git a/cpp2rust/cpp_rule_preprocessor.cpp b/cpp2rust/cpp_rule_preprocessor.cpp
deleted file mode 100644
index cff775b803..0000000000
--- a/cpp2rust/cpp_rule_preprocessor.cpp
+++ /dev/null
@@ -1,1132 +0,0 @@
-// Copyright (c) 2022-present INESC-ID.
-// Distributed under the MIT license that can be found in the LICENSE file.
-
-#include <clang/AST/ASTContext.h>
-#include <clang/AST/Attr.h>
-#include <clang/AST/Decl.h>
-#include <clang/AST/Expr.h>
-#include <clang/AST/PrettyPrinter.h>
-#include <clang/AST/RecursiveASTVisitor.h>
-#include <clang/ASTMatchers/ASTMatchFinder.h>
-#include <clang/ASTMatchers/ASTMatchers.h>
-#include <clang/Frontend/ASTUnit.h>
-#include <clang/Frontend/FrontendActions.h>
-#include <clang/Sema/Initialization.h>
-#include <clang/Sema/Lookup.h>
-#include <clang/Sema/Overload.h>
-#include <clang/Sema/Sema.h>
-#include <clang/Sema/Template.h>
-#include <clang/Tooling/CompilationDatabase.h>
-#include <clang/Tooling/Tooling.h>
-#include <llvm/ADT/ArrayRef.h>
-#include <llvm/ADT/SmallVector.h>
-#include <llvm/ADT/StringRef.h>
-#include <llvm/Support/CommandLine.h>
-#include <llvm/Support/FormatVariadic.h>
-#include <llvm/Support/JSON.h>
-#include <llvm/Support/MemoryBuffer.h>
-#include <llvm/Support/raw_ostream.h>
-
-#include <cstdlib>
-#include <filesystem>
-#include <string>
-
-#include "compat/platform_flags.h"
-#include "converter/converter_lib.h"
-#include "converter/printer.h"
-
-namespace fs = std::filesystem;
-
-namespace cpp2rust {
-
-enum LookupKind { RegularName, CXXMethodName, CXXConstructorName, ADL };
-
-struct LookupInfo {
-  clang::DeclarationName name;
-  LookupKind kind;
-  llvm::ArrayRef<clang::TemplateArgumentLoc> explicitArgs;
-
-  LookupInfo(const clang::Expr *expr) {
-    if (const auto *ul = llvm::dyn_cast<clang::UnresolvedLookupExpr>(expr)) {
-      clang::DeclarationName dname = ul->getName();
-      name = dname;
-      if (ul->requiresADL()) {
-        kind = LookupKind::ADL;
-      } else {
-        kind = LookupKind::RegularName;
-      }
-      explicitArgs = ul->template_arguments();
-    } else if (const auto *dm =
-                   llvm::dyn_cast<clang::CXXDependentScopeMemberExpr>(expr)) {
-      name = dm->getMember();
-      kind = LookupKind::CXXMethodName;
-      explicitArgs = dm->template_arguments();
-    } else if (const auto *um =
-                   llvm::dyn_cast<clang::UnresolvedMemberExpr>(expr)) {
-      name = um->getMemberName();
-      kind = LookupKind::CXXMethodName;
-      explicitArgs = um->template_arguments();
-    } else if (const auto *dref =
-                   llvm::dyn_cast<clang::DependentScopeDeclRefExpr>(expr)) {
-      clang::DeclarationName dname = dref->getDeclName();
-      if (dname.getNameKind() ==
-          clang::DeclarationName::NameKind::CXXConstructorName) {
-        name = dname;
-        kind = LookupKind::CXXConstructorName;
-      } else {
-        assert(0 && "Unsupported dref name kind");
-      }
-    } else if (llvm::isa<clang::CXXUnresolvedConstructExpr>(expr)) {
-      kind = LookupKind::CXXConstructorName;
-    } else {
-      expr->dump();
-      assert(0 && "Unsupported lookup expression");
-    }
-  }
-};
-
-class Callback : public clang::ast_matchers::MatchFinder::MatchCallback {
-public:
-  explicit Callback(llvm::json::Object &out) : out_(out) {}
-
-  void init(clang::Sema &sema) {
-    sema_ = &sema;
-    clang::SourceManager &sm = sema.Context.getSourceManager();
-    loc_ = sm.getLocForStartOfFile(sm.getMainFileID());
-  }
-
-  void run(const clang::ast_matchers::MatchFinder::MatchResult &R) override {
-    assert(sema_);
-    if (auto func = R.Nodes.getNodeAs<clang::FunctionDecl>("validate_func")) {
-      const char *err = nullptr;
-      if (auto body =
-              clang::dyn_cast_or_null<clang::CompoundStmt>(func->getBody())) {
-        if (body->size() != 1) {
-          err = "body must contain exactly one statement (a return)";
-        } else if (!clang::isa<clang::ReturnStmt>(*body->body_begin())) {
-          err = "body must be a return statement";
-        }
-      } else {
-        err = "body cannot be empty";
-      }
-
-      if (err) {
-        llvm::errs() << "ERROR: " << func->getQualifiedNameAsString() << ": "
-                     << err << '\n';
-        std::exit(EXIT_FAILURE);
-      }
-      return;
-    }
-    if (auto var = R.Nodes.getNodeAs<clang::TypedefNameDecl>("tvar")) {
-      clang::QualType type = var->getUnderlyingType();
-      if (auto *alias = llvm::dyn_cast<clang::TypeAliasDecl>(var)) {
-        if (auto *tdecl = alias->getDescribedAliasTemplate()) {
-          type = lookupType(tdecl);
-        }
-      }
-      auto src =
-          Printer::ToString(*R.Context, type, Printer::ScalarSugar::kPreserve);
-      out_.try_emplace(var->getQualifiedNameAsString(), std::move(src));
-      return;
-    }
-
-    if (auto func = R.Nodes.getNodeAs<clang::FunctionDecl>("func")) {
-      auto add = [&](std::string &&src) {
-        out_.try_emplace(func->getQualifiedNameAsString(), std::move(src));
-      };
-
-      if (const auto *fcall = R.Nodes.getNodeAs<clang::CallExpr>("fcall")) {
-        if (fcall->getDirectCallee()) {
-          add(Printer::ToString(*R.Context, fcall));
-          return;
-        }
-
-        LookupInfo lookup(fcall->getCallee());
-        clang::FunctionDecl *rule = nullptr;
-        clang::FunctionDecl *decl = lookupCalledDecl(
-            func->getDescribedFunctionTemplate(), lookup, &rule);
-        if (HasFunctionParameterPack(func) && HasFunctionParameterPack(decl)) {
-          addPackRule(func, rule, decl);
-          return;
-        }
-        add(Printer::ToString(*R.Context, decl));
-        return;
-      }
-      if (const auto *ctor =
-              R.Nodes.getNodeAs<clang::CXXConstructExpr>("ctor")) {
-        if (ctor->getConstructor()) {
-          add(Printer::ToString(*R.Context, ctor));
-          return;
-        }
-      }
-      if (const auto *muse = R.Nodes.getNodeAs<clang::MemberExpr>("muse")) {
-        if (llvm::isa<clang::FieldDecl>(muse->getMemberDecl())) {
-          add(Printer::ToString(*R.Context, muse));
-          return;
-        }
-      }
-      if (const auto *um =
-              R.Nodes.getNodeAs<clang::UnresolvedMemberExpr>("umuse")) {
-        add(Printer::ToString(*R.Context, um));
-        return;
-      }
-      if (R.Nodes.getNodeAs<clang::DeclRefExpr>("declref")) {
-        if (const auto *enum_val =
-                R.Nodes.getNodeAs<clang::EnumConstantDecl>("enum_val")) {
-          add(Printer::ToString(*R.Context, enum_val));
-          return;
-        } else if (const auto *decl =
-                       R.Nodes.getNodeAs<clang::VarDecl>("decl")) {
-          add(Printer::ToString(*R.Context, decl));
-          return;
-        }
-      }
-      if (const auto *uop =
-              R.Nodes.getNodeAs<clang::UnaryOperator>("udeclref")) {
-        add(Printer::ToString(*R.Context, uop));
-        return;
-      }
-      if (const auto *dsme =
-              R.Nodes.getNodeAs<clang::CXXDependentScopeMemberExpr>("dsme")) {
-        if (dsme->isArrow()) {
-          clang::MemberExpr *expr = lookupArrowAccess(
-              func->getDescribedFunctionTemplate(), dsme->getMemberNameInfo(),
-              dsme->getQualifierLoc());
-          add(Printer::ToString(*R.Context, expr));
-          return;
-        }
-        clang::NamedDecl *decl = lookupMemberAccess(
-            func->getDescribedFunctionTemplate(), dsme->getMember());
-        add(Printer::ToString(*R.Context, decl));
-        return;
-      }
-      if (const auto *uctor =
-              R.Nodes.getNodeAs<clang::CXXUnresolvedConstructExpr>("uctor")) {
-        LookupInfo lookup(uctor);
-        clang::NamedDecl *decl = lookupCalledDecl(
-            func->getDescribedFunctionTemplate(), lookup, nullptr);
-        add(Printer::ToString(*R.Context, decl));
-        return;
-      }
-      if (const auto *lit =
-              R.Nodes.getNodeAs<clang::IntegerLiteral>("macro_int")) {
-        if (lit->getBeginLoc().isMacroID()) {
-          add(Printer::ToString(*R.Context, lit));
-        }
-        return;
-      }
-    }
-  }
-
-private:
-  llvm::json::Object &out_;
-  clang::Sema *sema_ = nullptr;
-  clang::SourceLocation loc_;
-
-  void addPackRule(const clang::FunctionDecl *func, clang::FunctionDecl *rule,
-                   clang::FunctionDecl *callee) {
-    auto key = Printer::ToString(sema_->Context, callee);
-    auto init_type = getInitType(func, rule);
-    if (init_type.isNull()) {
-      out_.try_emplace(func->getQualifiedNameAsString(), std::move(key));
-      return;
-    }
-
-    auto [depth, index] = findTemplateArgument(callee, init_type);
-    out_.try_emplace(func->getQualifiedNameAsString(),
-                     llvm::json::Object{
-                         {"key", std::move(key)},
-                         {"init_type", llvm::json::Object{{"depth", depth},
-                                                          {"index", index}}},
-                     });
-  }
-
-  clang::QualType getInitType(const clang::FunctionDecl *func,
-                              clang::FunctionDecl *rule) {
-    auto pattern = func->parameters()
-                       .back()
-                       ->getType()
-                       ->castAs<clang::PackExpansionType>()
-                       ->getPattern()
-                       .getNonReferenceType();
-    const auto *alias = pattern->getAs<clang::TemplateSpecializationType>();
-    if (!alias || !alias->isTypeAlias() ||
-        alias->getTemplateName().getAsTemplateDecl()->getName() != "Init") {
-      return clang::QualType();
-    }
-
-    auto *tmpl = func->getDescribedFunctionTemplate();
-    const clang::Sema::InstantiatingTemplate Inst(*sema_, loc_, tmpl);
-    return getSubstType(Inst, alias->template_arguments()[0].getAsType(),
-                        rule->getTemplateSpecializationArgs()->asArray());
-  }
-
-  std::pair<unsigned, unsigned>
-  findTemplateArgument(const clang::FunctionDecl *callee,
-                       clang::QualType type) {
-    auto args = sema_->getTemplateInstantiationArgs(callee);
-    for (unsigned depth = 0; depth < args.getNumLevels(); ++depth) {
-      for (unsigned index = 0; index < args.getNumSubsitutedArgs(depth);
-           ++index) {
-        const auto &arg = args(depth, index);
-        if (arg.getKind() == clang::TemplateArgument::Type &&
-            sema_->Context.hasSameType(arg.getAsType(), type)) {
-          return {depth, index};
-        }
-      }
-    }
-    llvm::errs() << "ERROR: Init type "
-                 << Printer::ToString(sema_->Context, type)
-                 << " is not a template argument of "
-                 << Printer::ToString(sema_->Context, callee) << '\n';
-    std::exit(EXIT_FAILURE);
-  }
-
-  void forceCompleteDefinition(clang::QualType type) {
-    type = type.getCanonicalType();
-    if (type->isPointerType()) {
-      type = type->getPointeeType();
-    }
-
-    if (!type->isIncompleteType()) {
-      return;
-    }
-
-    sema_->RequireCompleteType(loc_, type,
-                               clang::Sema::CompleteTypeKind::Normal,
-                               clang::diag::err_incomplete_type);
-
-    if (auto *spec =
-            llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>(
-                type->getAsCXXRecordDecl())) {
-      for (const auto *decl : spec->decls()) {
-        if (const auto *tdef = llvm::dyn_cast<clang::TypedefNameDecl>(decl)) {
-          clang::QualType tdef_t = tdef->getUnderlyingType();
-          forceCompleteDefinition(tdef_t);
-        }
-      }
-
-      for (const auto &arg : spec->getTemplateArgs().asArray()) {
-        if (arg.getKind() == clang::TemplateArgument::Type) {
-          forceCompleteDefinition(arg.getAsType());
-        }
-      }
-    }
-  }
-
-  clang::FunctionDecl *deduceTemplateArguments(
-      clang::FunctionTemplateDecl *decl, llvm::ArrayRef<clang::Expr *> callArgs,
-      clang::QualType obj_t, clang::Expr::Classification exprClass,
-      clang::TemplateArgumentListInfo *explicitArgs = nullptr) {
-    clang::FunctionDecl *spec = nullptr;
-    clang::sema::TemplateDeductionInfo info((loc_));
-    auto check = [](llvm::ArrayRef<clang::QualType>, bool) -> bool {
-      return false;
-    };
-
-    auto result = sema_->DeduceTemplateArguments(
-        decl, explicitArgs, callArgs, spec, info, false, false, false, obj_t,
-        exprClass, false, check);
-
-    if (result == clang::TemplateDeductionResult::Success) {
-      return spec;
-    }
-
-    if (result == clang::TemplateDeductionResult::SubstitutionFailure ||
-        result == clang::TemplateDeductionResult::ConstraintsNotSatisfied) {
-      if (const auto *deduced = info.takeCanonical()) {
-        clang::TemplateArgumentListInfo targsInfo;
-        for (const auto &arg : deduced->asArray()) {
-          targsInfo.addArgument(
-              sema_->getTrivialTemplateArgumentLoc(arg, {}, loc_));
-        }
-
-        clang::DefaultArguments defaultArgs;
-        clang::Sema::CheckTemplateArgumentInfo ctai;
-        clang::Sema::InstantiatingTemplate Inst(*sema_, loc_, decl);
-        auto invalid = sema_->CheckTemplateArgumentList(
-            decl, decl->getTemplateParameters(), loc_, targsInfo, defaultArgs,
-            true, ctai);
-
-        if (!invalid) {
-          return sema_->InstantiateFunctionDeclaration(decl, deduced, loc_);
-        }
-      }
-    }
-
-    return nullptr;
-  }
-
-  clang::NamespaceDecl *createNamespaceDecl() {
-    auto &ctx = sema_->getASTContext();
-    auto *tu = ctx.getTranslationUnitDecl();
-    auto *ns = clang::NamespaceDecl::Create(ctx, tu, false, loc_, loc_, nullptr,
-                                            nullptr, false);
-    tu->addDecl(ns);
-    return ns;
-  }
-
-  clang::RecordDecl *
-  createRecordDecl(llvm::StringRef name,
-                   clang::QualType base = clang::QualType()) {
-    bool owned = true;
-    bool dependent = false;
-    clang::CXXScopeSpec scope;
-    clang::MultiTemplateParamsArg args;
-    auto decl = sema_->ActOnTag(
-        sema_->getCurScope(), clang::DeclSpec::TST_struct,
-        clang::TagUseKind::Definition, loc_, scope,
-        &sema_->Context.Idents.get(name), loc_, clang::ParsedAttributesView(),
-        clang::AS_none, loc_, args, owned, dependent, loc_, false,
-        clang::TypeResult(), false, false, clang::OffsetOfKind::Outside);
-    assert(decl.isUsable() && "Record decl creation failed");
-    auto *rdecl = decl.getAs<clang::RecordDecl>();
-
-    rdecl->startDefinition();
-    if (!base.isNull()) {
-      clang::CXXBaseSpecifier baseSpec(
-          clang::SourceRange(loc_, loc_), false, true, clang::AS_public,
-          sema_->Context.getTrivialTypeSourceInfo(base, loc_),
-          /*EllipsisLoc=*/clang::SourceLocation());
-      const clang::CXXBaseSpecifier *bases[] = {&baseSpec};
-      llvm::cast<clang::CXXRecordDecl>(rdecl)->setBases(bases, 1);
-    }
-    rdecl->completeDefinition();
-    return rdecl;
-  }
-
-  static clang::QualType getNTTPType(const clang::TemplateArgument &arg) {
-    switch (arg.getKind()) {
-    case clang::TemplateArgument::Integral:
-      return arg.getIntegralType();
-    case clang::TemplateArgument::Declaration:
-      return arg.getParamTypeForDecl();
-    case clang::TemplateArgument::NullPtr:
-      return arg.getNullPtrType();
-    case clang::TemplateArgument::StructuralValue:
-      return arg.getStructuralValueType();
-    default:
-      return clang::QualType();
-    }
-  }
-
-  clang::QualType
-  getTemplateIdType(clang::ClassTemplateDecl *decl,
-                    llvm::ArrayRef<clang::TemplateArgument> args) {
-    clang::TemplateArgumentListInfo info(loc_, loc_);
-    for (const clang::TemplateArgument &arg : args) {
-      info.addArgument(
-          sema_->getTrivialTemplateArgumentLoc(arg, getNTTPType(arg), loc_));
-    }
-    return sema_->CheckTemplateIdType(clang::ElaboratedTypeKeyword::None,
-                                      clang::TemplateName(decl), loc_, info,
-                                      sema_->getCurScope(),
-                                      /*ForNestedNameSpecifier=*/false);
-  }
-
-  using MirrorMap = llvm::SmallDenseMap<const clang::ClassTemplateDecl *,
-                                        clang::ClassTemplateDecl *>;
-
-  clang::TypeSourceInfo *findMatch(MirrorMap &substs, clang::QualType type) {
-    const auto *tst = type->getAs<clang::TemplateSpecializationType>();
-    if (!tst) {
-      return nullptr;
-    }
-
-    const auto *tdecl = llvm::dyn_cast_or_null<clang::ClassTemplateDecl>(
-        tst->getTemplateName().getAsTemplateDecl());
-    if (!tdecl) {
-      return nullptr;
-    }
-
-    if (auto it = substs.find(tdecl->getCanonicalDecl()); it != substs.end()) {
-      auto match = getTemplateIdType(it->second, tst->template_arguments());
-      assert(!match.isNull());
-      return sema_->Context.getTrivialTypeSourceInfo(match, loc_);
-    }
-    return nullptr;
-  }
-
-  clang::ClassTemplateDecl *
-  createInheritingTemplate(llvm::StringRef name, clang::ClassTemplateDecl *decl,
-                           MirrorMap &substs) {
-    clang::ASTContext &ctx = sema_->Context;
-    auto *pattern = clang::CXXRecordDecl::Create(
-        ctx, clang::TagTypeKind::Struct, sema_->CurContext, loc_, loc_,
-        &ctx.Idents.get(name));
-
-    auto *mirror = clang::ClassTemplateDecl::Create(
-        ctx, sema_->CurContext, loc_,
-        clang::DeclarationName(&ctx.Idents.get(name)),
-        decl->getTemplateParameters(), pattern);
-    pattern->setDescribedClassTemplate(mirror);
-    mirror->setAccess(clang::AS_public);
-    substs.try_emplace(decl->getCanonicalDecl(), mirror);
-
-    clang::QualType base_t = getTemplateIdType(
-        decl, decl->getTemplateParameters()->getInjectedTemplateArgs(ctx));
-    assert(!base_t.isNull() && "Failed building mirror base");
-
-    pattern->startDefinition();
-    clang::CXXBaseSpecifier base(clang::SourceRange(loc_, loc_), false, true,
-                                 clang::AS_public,
-                                 ctx.getTrivialTypeSourceInfo(base_t, loc_),
-                                 /*EllipsisLoc=*/clang::SourceLocation());
-    const clang::CXXBaseSpecifier *bases[] = {&base};
-    pattern->setBases(bases, 1);
-
-    for (auto *member : decl->getTemplatedDecl()->decls()) {
-      if (const auto *td = llvm::dyn_cast<clang::TypedefNameDecl>(member)) {
-        if (auto *replacement = findMatch(substs, td->getUnderlyingType())) {
-          auto *copy = clang::TypedefDecl::Create(
-              ctx, pattern, loc_, loc_, td->getIdentifier(), replacement);
-          copy->setAccess(clang::AS_public);
-          pattern->addDecl(copy);
-        }
-      } else if (auto *tdecl =
-                     llvm::dyn_cast<clang::ClassTemplateDecl>(member)) {
-        clang::Sema::ContextRAII savedContext(*sema_, pattern);
-        createInheritingTemplate(tdecl->getName(), tdecl, substs);
-      }
-    }
-
-    pattern->completeDefinition();
-    sema_->CurContext->addDecl(mirror);
-    return mirror;
-  }
-
-  clang::QualType createMirrorType(llvm::StringRef name, clang::QualType hint) {
-    clang::ASTContext &ctx = sema_->Context;
-    forceCompleteDefinition(hint);
-
-    const auto *hdecl = hint->getAsCXXRecordDecl();
-    assert(hdecl && "Failed resolving hint record declaration");
-    assert(hdecl->isCompleteDefinition() && "Incomplete hint");
-
-    const auto *hspec =
-        llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(hdecl);
-    if (!hspec) {
-      // if it is not a template specialization inheriting from it suffices
-      clang::RecordDecl *rdecl = createRecordDecl(name, hint);
-      return ctx.getTagType(clang::ElaboratedTypeKeyword::None,
-                            rdecl->getQualifier(), rdecl, false);
-    }
-
-    MirrorMap substs;
-    auto *mirror =
-        createInheritingTemplate(name, hspec->getSpecializedTemplate(), substs);
-    clang::QualType spec =
-        getTemplateIdType(mirror, hspec->getTemplateArgs().asArray());
-    assert(!spec.isNull() && spec->getAsCXXRecordDecl());
-
-    // required to print Tn instead of Tn<arg1, arg2, ...>
-    clang::NamespaceDecl *ns = createNamespaceDecl();
-    auto *alias =
-        clang::TypeAliasDecl::Create(ctx, ns, loc_, loc_, &ctx.Idents.get(name),
-                                     ctx.getTrivialTypeSourceInfo(spec, loc_));
-    ns->addDecl(alias);
-
-    clang::QualType alias_t = ctx.getTypedefType(
-        clang::ElaboratedTypeKeyword::None, std::nullopt, alias);
-    spec->getAsCXXRecordDecl()->addAttr(
-        clang::PreferredNameAttr::CreateImplicit(
-            ctx, ctx.getTrivialTypeSourceInfo(alias_t, loc_)));
-
-    return ctx.getCanonicalType(spec);
-  }
-
-  clang::QualType getSubstType(const clang::Sema::InstantiatingTemplate &Inst,
-                               clang::QualType type,
-                               llvm::ArrayRef<clang::TemplateArgument> args) {
-    assert(!Inst.isInvalid() && "Invalid instantiation context");
-    clang::MultiLevelTemplateArgumentList mtal;
-    mtal.setKind(clang::TemplateSubstitutionKind::Rewrite);
-    mtal.addOuterTemplateArguments(args);
-
-    clang::TypeSourceInfo *tsi =
-        sema_->SubstType(sema_->Context.getTrivialTypeSourceInfo(type), mtal,
-                         loc_, clang::DeclarationName());
-    assert(tsi && "Template argument type instantiation failed");
-    return tsi->getType();
-  }
-
-  clang::QualType
-  getDefaultArg(clang::TemplateDecl *decl,
-                const clang::TemplateTypeParmDecl *parm,
-                llvm::ArrayRef<clang::TemplateArgument> currentArgs) {
-    clang::QualType type = parm->getDefaultArgument().getArgument().getAsType();
-    if (!type->isDependentType()) {
-      return type;
-    }
-
-    const clang::Sema::InstantiatingTemplate Inst(*sema_, loc_, decl);
-    return getSubstType(Inst, type, currentArgs);
-  }
-
-  clang::VarDecl *createVarDecl(clang::QualType type, llvm::StringRef name,
-                                clang::StorageClass sclass = clang::SC_None) {
-    clang::ASTContext &ctx = sema_->Context;
-    clang::VarDecl *decl = clang::VarDecl::Create(
-        ctx, sema_->CurContext, loc_, loc_, &ctx.Idents.get(name),
-        type.getNonReferenceType(), nullptr, sclass);
-    sema_->CurContext->addDecl(decl);
-    decl->markUsed(ctx);
-    return decl;
-  }
-
-  clang::DeclRefExpr *createDeclRefExpr(clang::VarDecl *decl) {
-    const clang::DeclarationNameInfo nameInfo(decl->getDeclName(), loc_);
-    return sema_->BuildDeclRefExpr(decl, decl->getType(), clang::VK_LValue,
-                                   nameInfo, decl->getQualifierLoc());
-  }
-
-  clang::DeclRefExpr *createConstexprDeclRefExpr(clang::QualType type,
-                                                 llvm::StringRef name) {
-    clang::VarDecl *decl = createVarDecl(type, name, clang::SC_Static);
-    decl->setConstexpr(true);
-
-    clang::Expr *init;
-    clang::ASTContext &ctx = sema_->Context;
-    if (type->isIntegerType()) {
-      init = clang::IntegerLiteral::Create(
-          ctx, llvm::APInt(ctx.getIntWidth(type), 1), type, loc_);
-    } else {
-      init = new (ctx) clang::ImplicitValueInitExpr(type);
-    }
-    decl->setInit(init);
-    return createDeclRefExpr(decl);
-  }
-
-  clang::OpaqueValueExpr *createOpaqueValueExpr(clang::QualType type) {
-    return new (sema_->Context) clang::OpaqueValueExpr(
-        loc_, type.getNonReferenceType(),
-        type->isRValueReferenceType() ? clang::VK_XValue : clang::VK_LValue);
-  }
-
-  void
-  createTemplateArguments(clang::TemplateDecl *decl,
-                          llvm::SmallVectorImpl<clang::TemplateArgument> &out) {
-    for (clang::NamedDecl *param : *decl->getTemplateParameters()) {
-      if (const auto *ttp =
-              llvm::dyn_cast<clang::TemplateTypeParmDecl>(param)) {
-        clang::QualType type;
-        if (param->isTemplateParameterPack()) {
-          out.emplace_back(clang::TemplateArgument::getEmptyPack());
-          continue;
-        }
-        if (ttp->hasDefaultArgument()) {
-          clang::QualType hint = getDefaultArg(decl, ttp, out);
-          assert(!hint.isNull() && "Failed retrieving type hint");
-          type = createMirrorType(param->getName(), hint);
-        } else {
-          clang::RecordDecl *rdecl = createRecordDecl(param->getName());
-          type = sema_->Context.getTagType(clang::ElaboratedTypeKeyword::None,
-                                           rdecl->getQualifier(), rdecl, false);
-        }
-        assert(!type.isNull() && "Template type argument creation failed");
-        out.emplace_back(type);
-      } else if (const auto *nttp =
-                     llvm::dyn_cast<clang::NonTypeTemplateParmDecl>(param)) {
-        clang::QualType type = nttp->getType();
-        if (type->isDependentType()) {
-          const clang::Sema::InstantiatingTemplate Inst(*sema_, loc_, decl);
-          type = getSubstType(Inst, type, out);
-        }
-        clang::DeclRefExpr *var =
-            createConstexprDeclRefExpr(type, param->getName());
-        out.emplace_back(var, true);
-      } else {
-        assert(0 && "Unsupported template param kind");
-      }
-    }
-  }
-
-  clang::FunctionDecl *instantiateRuleDecl(clang::FunctionTemplateDecl *decl) {
-    llvm::SmallVector<clang::TemplateArgument, 8> args;
-    createTemplateArguments(decl, args);
-    return sema_->InstantiateFunctionDeclaration(
-        decl, clang::TemplateArgumentList::CreateCopy(sema_->Context, args),
-        loc_);
-  }
-
-  clang::FunctionDecl *createCandidate(
-      clang::NamedDecl *decl, llvm::ArrayRef<clang::Expr *> callArgs,
-      clang::TemplateArgumentListInfo *explicitArgs = nullptr,
-      clang::QualType obj_t = clang::QualType(),
-      clang::Expr::Classification eclass = clang::Expr::Classification()) {
-    if (auto *tdecl = llvm::dyn_cast<clang::FunctionTemplateDecl>(decl)) {
-      if (auto *fdecl = deduceTemplateArguments(tdecl, callArgs, obj_t, eclass,
-                                                explicitArgs)) {
-        return fdecl;
-      }
-      return nullptr;
-    }
-    return llvm::dyn_cast<clang::FunctionDecl>(decl);
-  }
-
-  clang::CXXRecordDecl *resolveCXXRecordDecl(clang::QualType obj_t) {
-    obj_t = obj_t.getCanonicalType();
-    while (obj_t->isPointerOrReferenceType()) {
-      obj_t = obj_t->getPointeeType();
-    }
-
-    forceCompleteDefinition(obj_t);
-    if (auto *rdecl = obj_t->getAsCXXRecordDecl()) {
-      return rdecl->getDefinition();
-    }
-    return nullptr;
-  }
-
-  void regularNameLookup(llvm::ArrayRef<clang::Expr *> callArgs,
-                         clang::TemplateArgumentListInfo *explicitTArgs,
-                         clang::DeclarationName &name,
-                         clang::OverloadCandidateSet &candidates) {
-    clang::LookupResult decls(*sema_, name, loc_,
-                              clang::Sema::LookupOrdinaryName);
-    if (clang::NamespaceDecl *std_ns = sema_->getStdNamespace()) {
-      sema_->LookupQualifiedName(decls, std_ns);
-    }
-    if (decls.empty()) {
-      decls.clear();
-      sema_->LookupQualifiedName(decls,
-                                 sema_->Context.getTranslationUnitDecl());
-    }
-    for (auto *ndecl : decls) {
-      if (auto *candidate = createCandidate(ndecl, callArgs, explicitTArgs)) {
-        sema_->AddOverloadCandidate(
-            candidate, clang::DeclAccessPair::make(candidate, clang::AS_public),
-            callArgs, candidates, false);
-      }
-    }
-
-    for (const auto *arg : callArgs) {
-      if (auto *rdecl = resolveCXXRecordDecl(arg->getType())) {
-        for (auto *frdecl : rdecl->friends()) {
-          auto *fd = frdecl->getFriendDecl();
-          if (!fd) {
-            continue;
-          }
-
-          if (auto *ndecl = llvm::dyn_cast<clang::NamedDecl>(fd);
-              ndecl && ndecl->getDeclName() == name) {
-            if (auto *candidate =
-                    createCandidate(ndecl, callArgs, explicitTArgs)) {
-              sema_->AddOverloadCandidate(
-                  candidate,
-                  clang::DeclAccessPair::make(candidate, clang::AS_public),
-                  callArgs, candidates, false);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  void cxxMethodNameLookup(clang::QualType obj_t,
-                           llvm::ArrayRef<clang::Expr *> callArgs,
-                           clang::TemplateArgumentListInfo *explicitTArgs,
-                           clang::DeclarationName &name,
-                           clang::OverloadCandidateSet &candidates) {
-    clang::CXXRecordDecl *rdecl = resolveCXXRecordDecl(obj_t);
-    assert(rdecl && "Failed fetching record decl");
-    clang::LookupResult members(*sema_, name, loc_,
-                                clang::Sema::LookupMemberName);
-    sema_->LookupQualifiedName(members, rdecl);
-
-    auto eclass = clang::Expr::Classification::makeSimpleLValue();
-    for (auto *ndecl : members) {
-      if (auto *candidate =
-              createCandidate(ndecl, callArgs, explicitTArgs, obj_t, eclass)) {
-        sema_->AddMethodCandidate(
-            clang::DeclAccessPair::make(candidate, clang::AS_public), obj_t,
-            eclass, callArgs, candidates);
-      }
-    }
-  }
-
-  void cxxConstructorNameLookup(clang::QualType obj_t,
-                                llvm::ArrayRef<clang::Expr *> callArgs,
-                                clang::OverloadCandidateSet &candidates) {
-    clang::CXXRecordDecl *rdecl = resolveCXXRecordDecl(obj_t);
-    assert(rdecl && "Failed fetching record decl");
-    clang::DeclContextLookupResult ctors = sema_->LookupConstructors(rdecl);
-
-    for (auto *ndecl : ctors) {
-      if (auto *candidate = createCandidate(ndecl, callArgs)) {
-        sema_->AddOverloadCandidate(
-            candidate, clang::DeclAccessPair::make(candidate, clang::AS_public),
-            callArgs, candidates, false);
-      }
-    }
-  }
-
-  void adlLookup(llvm::ArrayRef<clang::Expr *> callArgs,
-                 clang::DeclarationName &name,
-                 clang::OverloadCandidateSet &candidates) {
-    clang::ADLResult adl;
-    sema_->ArgumentDependentLookup(name, loc_, callArgs, adl);
-
-    for (auto *ndecl : adl) {
-      if (auto *candidate = createCandidate(ndecl, callArgs)) {
-        sema_->AddOverloadCandidate(
-            candidate, clang::DeclAccessPair::make(candidate, clang::AS_public),
-            callArgs, candidates, false);
-      }
-    }
-  }
-
-  clang::FunctionDecl *lookupCalledDecl(clang::FunctionTemplateDecl *decl,
-                                        LookupInfo &lookup,
-                                        clang::FunctionDecl **rule_out) {
-    clang::NamespaceDecl *ns = createNamespaceDecl();
-    clang::Sema::ContextRAII savedContext(*sema_, ns);
-    clang::FunctionDecl *rule = instantiateRuleDecl(decl);
-    assert(rule && "Rule instantiation failed");
-    if (rule_out) {
-      *rule_out = rule;
-    }
-    llvm::ArrayRef<clang::ParmVarDecl *> parms = rule->parameters();
-    auto csk = lookup.name.getNameKind() ==
-                       clang::DeclarationName::NameKind::CXXOperatorName
-                   ? clang::OverloadCandidateSet::CSK_Operator
-                   : clang::OverloadCandidateSet::CSK_Normal;
-
-    llvm::SmallVector<clang::Expr *, 8> callArgs;
-    for (const auto *parm : parms) {
-      clang::QualType parm_t = parm->getType();
-      forceCompleteDefinition(parm_t);
-      callArgs.emplace_back(createOpaqueValueExpr(parm_t));
-    }
-
-    llvm::ArrayRef<clang::TemplateArgument> ruleTArgs =
-        rule->getTemplateSpecializationArgs()->asArray();
-    clang::TemplateArgumentListInfo explicitTArgs;
-
-    {
-      const clang::Sema::InstantiatingTemplate Inst(*sema_, loc_, decl);
-      assert(!Inst.isInvalid() && "Invalid instantiation context");
-      for (const auto &argloc : lookup.explicitArgs) {
-        const auto &arg = argloc.getArgument();
-        if (!arg.isDependent()) {
-          explicitTArgs.addArgument(argloc);
-          continue;
-        }
-
-        clang::TemplateArgument inst;
-        if (arg.getKind() == clang::TemplateArgument::Type) {
-          inst = clang::TemplateArgument(
-              getSubstType(Inst, arg.getAsType(), ruleTArgs));
-        } else if (arg.getKind() == clang::TemplateArgument::Expression) {
-          if (auto *expr =
-                  llvm::dyn_cast<clang::DeclRefExpr>(arg.getAsExpr())) {
-            const auto *nttp =
-                llvm::dyn_cast<clang::NonTypeTemplateParmDecl>(expr->getDecl());
-            assert(nttp && "Unexpected decl in expr");
-            inst = ruleTArgs[nttp->getIndex()];
-          } else {
-            assert(0 && "Unsupported explicit template argument expression");
-          }
-        } else {
-          assert(0 && "Unsupported explicit template argument kind");
-        }
-
-        explicitTArgs.addArgument(
-            sema_->getTrivialTemplateArgumentLoc(inst, {}, loc_));
-      }
-    }
-
-    clang::DeclarationName name = lookup.name;
-    if (clang::QualType nameType = name.getCXXNameType();
-        !nameType.isNull() && nameType->isDependentType()) {
-      const clang::Sema::InstantiatingTemplate Inst(*sema_, loc_, decl);
-      assert(!Inst.isInvalid() && "Invalid instantiation context");
-      clang::MultiLevelTemplateArgumentList mtal;
-      mtal.setKind(clang::TemplateSubstitutionKind::Rewrite);
-      mtal.addOuterTemplateArguments(ruleTArgs);
-      name = sema_->SubstDeclarationNameInfo({name, loc_}, mtal).getName();
-    }
-
-    clang::OverloadCandidateSet candidates(loc_, csk);
-    switch (lookup.kind) {
-    case LookupKind::RegularName:
-      regularNameLookup(callArgs, &explicitTArgs, name, candidates);
-      break;
-    case LookupKind::CXXMethodName: {
-      llvm::ArrayRef<clang::Expr *> margs = callArgs;
-      cxxMethodNameLookup(margs.front()->getType().getNonReferenceType(),
-                          margs.drop_front(), &explicitTArgs, name, candidates);
-      break;
-    }
-    case LookupKind::CXXConstructorName:
-      cxxConstructorNameLookup(rule->getReturnType(), callArgs, candidates);
-      break;
-    case LookupKind::ADL:
-      regularNameLookup(callArgs, &explicitTArgs, name, candidates);
-      adlLookup(callArgs, name, candidates);
-      break;
-    }
-
-    clang::OverloadCandidateSet::iterator best;
-    switch (candidates.BestViableFunction(*sema_, loc_, best)) {
-    case clang::OverloadingResult::OR_Success:
-      return best->Function;
-    case clang::OverloadingResult::OR_Ambiguous:
-      for (auto &candidate : candidates) {
-        if (candidate.Viable) {
-          return candidate.Function;
-        }
-      }
-      break;
-    case clang::OverloadingResult::OR_No_Viable_Function:
-      llvm::errs() << "No viable function\n";
-      break;
-    case clang::OverloadingResult::OR_Deleted:
-      llvm::errs() << "Deleted function selected\n";
-      break;
-    }
-
-    assert(0 && "Rule resolution failed");
-    return nullptr;
-  }
-
-  clang::NamedDecl *lookupMemberAccess(clang::FunctionTemplateDecl *decl,
-                                       clang::DeclarationName name) {
-    clang::NamespaceDecl *ns = createNamespaceDecl();
-    clang::Sema::ContextRAII savedContext(*sema_, ns);
-    clang::FunctionDecl *rule = instantiateRuleDecl(decl);
-    assert(rule && "Rule instantiation failed");
-    clang::CXXRecordDecl *rdecl =
-        resolveCXXRecordDecl(rule->getParamDecl(0)->getType());
-    assert(rdecl && "Failed fetching record decl");
-    clang::LookupResult members(*sema_, name, loc_,
-                                clang::Sema::LookupMemberName);
-    sema_->LookupQualifiedName(members, rdecl);
-    assert(!members.empty() && "Rule resolution failed");
-    return members.getRepresentativeDecl();
-  }
-
-  clang::MemberExpr *
-  lookupArrowAccess(clang::FunctionTemplateDecl *decl,
-                    const clang::DeclarationNameInfo &nameInfo,
-                    clang::NestedNameSpecifierLoc nns) {
-    clang::NamespaceDecl *ns = createNamespaceDecl();
-    clang::Sema::ContextRAII savedContext(*sema_, ns);
-    clang::FunctionDecl *rule = instantiateRuleDecl(decl);
-    assert(rule && "Rule instantiation failed");
-
-    clang::Expr *obj = createOpaqueValueExpr(
-        rule->getParamDecl(0)->getType().getNonReferenceType());
-    auto arrow =
-        sema_->BuildOverloadedArrowExpr(sema_->getCurScope(), obj, loc_);
-    assert(arrow.isUsable() && "Overloaded arrow operator not found");
-
-    auto *base = arrow.getAs<clang::CXXOperatorCallExpr>();
-    assert(base && "Unexpected base type");
-
-    clang::CXXRecordDecl *rdecl =
-        resolveCXXRecordDecl(base->getType()->getPointeeType());
-    assert(rdecl && "Failed fetching record decl");
-
-    clang::LookupResult members(*sema_, nameInfo.getName(), loc_,
-                                clang::Sema::LookupMemberName);
-    sema_->LookupQualifiedName(members, rdecl);
-    for (auto *ndecl : members) {
-      if (auto *vdecl = llvm::dyn_cast<clang::ValueDecl>(ndecl)) {
-        clang::MemberExpr *access = sema_->BuildMemberExpr(
-            base, true, loc_, nns, loc_, vdecl,
-            clang::DeclAccessPair::make(vdecl, clang::AS_public), false,
-            nameInfo, vdecl->getType(), clang::VK_LValue, clang::OK_Ordinary);
-        assert(access && "Rule resolution failed");
-        return access;
-      }
-    }
-    assert(0 && "Rule resolution failed");
-    return nullptr;
-  }
-
-  clang::QualType lookupType(clang::TypeAliasTemplateDecl *decl) {
-    clang::NamespaceDecl *ns = createNamespaceDecl();
-    clang::Sema::ContextRAII savedContext(*sema_, ns);
-
-    llvm::SmallVector<clang::TemplateArgument, 4> args;
-    createTemplateArguments(decl, args);
-
-    clang::MultiLevelTemplateArgumentList mtal;
-    mtal.setKind(clang::TemplateSubstitutionKind::Rewrite);
-    mtal.addOuterTemplateArguments(args);
-
-    clang::Sema::InstantiatingTemplate TypeInst(*sema_, loc_, decl, args);
-    assert(!TypeInst.isInvalid() && "Invalid instantiation context");
-
-    clang::TypeSourceInfo *tsi =
-        sema_->SubstType(decl->getTemplatedDecl()->getTypeSourceInfo(), mtal,
-                         loc_, clang::DeclarationName());
-    assert(tsi && "Rule resolution failed");
-    return tsi->getType();
-  }
-};
-
-class ActionFactory : public clang::tooling::FrontendActionFactory {
-public:
-  explicit ActionFactory(llvm::json::Object &out) : cb_(out) {
-    using namespace clang::ast_matchers;
-    finder_.addMatcher(
-        returnStmt(
-            isExpansionInMainFile(),
-            hasReturnValue(ignoringImplicit(ignoringParenImpCasts(anyOf(
-                callExpr().bind("fcall"), cxxConstructExpr().bind("ctor"),
-                cxxFunctionalCastExpr(has(ignoringImplicit(
-                    ignoringParenImpCasts(cxxConstructExpr().bind("ctor"))))),
-                memberExpr(hasDeclaration(fieldDecl())).bind("muse"),
-                unresolvedMemberExpr().bind("umuse"),
-                declRefExpr(to(anyOf(enumConstantDecl().bind("enum_val"),
-                                     decl(unless(parmVarDecl())).bind("decl"))))
-                    .bind("declref"),
-                unaryOperator(hasUnaryOperand(
-                                  declRefExpr(to(decl(unless(parmVarDecl()))))))
-                    .bind("udeclref"),
-                cxxDependentScopeMemberExpr().bind("dsme"),
-                cxxUnresolvedConstructExpr().bind("uctor"),
-                integerLiteral().bind("macro_int"))))),
-            hasAncestor(functionDecl(isDefinition(),
-                                     matchesName("(^|::)f[0-9]+$"),
-                                     isExpansionInMainFile())
-                            .bind("func"))),
-        &cb_);
-
-    finder_.addMatcher(
-        typedefNameDecl(matchesName("(^|::)t[0-9]+$"), isExpansionInMainFile())
-            .bind("tvar"),
-        &cb_);
-
-    finder_.addMatcher(functionDecl(isDefinition(),
-                                    matchesName("(^|::)f[0-9]+$"),
-                                    isExpansionInMainFile())
-                           .bind("validate_func"),
-                       &cb_);
-  }
-
-  std::unique_ptr<clang::FrontendAction> create() override {
-    class ASTConsumer : public clang::ASTConsumer {
-    public:
-      explicit ASTConsumer(std::unique_ptr<clang::ASTConsumer> AC,
-                           clang::CompilerInstance &CI, Callback *CB)
-          : AC_(std::move(AC)), CI_(&CI), CB_(CB) {}
-
-      void HandleTranslationUnit(clang::ASTContext &ctx) override {
-        auto &DE = CI_->getDiagnostics();
-        if (DE.hasErrorOccurred()) {
-          std::exit(EXIT_FAILURE);
-        }
-        DE.setSuppressAllDiagnostics(true);
-        DE.setClient(new clang::IgnoringDiagConsumer(), true);
-        CB_->init(CI_->getSema());
-        AC_->HandleTranslationUnit(ctx);
-      }
-
-    private:
-      std::unique_ptr<clang::ASTConsumer> AC_;
-      clang::CompilerInstance *CI_;
-      Callback *CB_;
-    };
-
-    class Wrapped : public clang::ASTFrontendAction {
-      clang::ast_matchers::MatchFinder &F_;
-      Callback *CB_;
-
-    public:
-      explicit Wrapped(clang::ast_matchers::MatchFinder &MF, Callback &CB)
-          : F_(MF), CB_(&CB) {}
-
-      std::unique_ptr<clang::ASTConsumer>
-      CreateASTConsumer(clang::CompilerInstance &CI, llvm::StringRef) override {
-        return std::make_unique<ASTConsumer>(F_.newASTConsumer(), CI, CB_);
-      }
-    };
-    return std::make_unique<Wrapped>(finder_, cb_);
-  }
-
-private:
-  clang::ast_matchers::MatchFinder finder_;
-  Callback cb_;
-};
-
-void Extract(const std::filesystem::path &src_path, llvm::json::Object &out,
-             llvm::ArrayRef<llvm::StringRef> cxx_flags) {
-  auto flags = getPlatformClangBeginFlags();
-  flags.insert(flags.end(), cxx_flags.begin(), cxx_flags.end());
-  auto end_flags = getPlatformClangEndFlags();
-  flags.insert(flags.end(), end_flags.begin(), end_flags.end());
-  auto code = llvm::MemoryBuffer::getFile(src_path.string());
-  if (!code) {
-    llvm::errs() << "ERROR: cannot read " << src_path.string() << '\n';
-    std::exit(EXIT_FAILURE);
-  }
-  ActionFactory factory(out);
-  clang::tooling::runToolOnCodeWithArgs(
-      factory.create(), (*code)->getBuffer(), flags, src_path.string(),
-      src_path.extension() == ".c" ? CLANG_C_COMPILER : CLANG_CXX_COMPILER);
-}
-
-} // namespace cpp2rust
-
-namespace {
-
-llvm::cl::OptionCategory cat("cpp-rule-preprocessor options");
-
-llvm::cl::opt<std::string>
-    SrcDir("dir",
-           llvm::cl::desc("Path to a rule directory containing src.c and/or "
-                          "src.cpp."),
-           llvm::cl::value_desc("rule-dir"), llvm::cl::Required,
-           llvm::cl::cat(cat));
-
-llvm::cl::opt<std::string>
-    OutPath("out", llvm::cl::desc("Path of the ir_src.json file to write."),
-            llvm::cl::value_desc("out.json"), llvm::cl::Required,
-            llvm::cl::cat(cat));
-
-llvm::cl::list<std::string> CXXFlags("cxxflags",
-                                     llvm::cl::desc("Additional CXXFLAGS"),
-                                     llvm::cl::value_desc("cxxflags"),
-                                     llvm::cl::ZeroOrMore, llvm::cl::cat(cat));
-
-} // namespace
-
-int main(int argc, char *argv[]) {
-  llvm::cl::HideUnrelatedOptions(cat);
-  llvm::cl::ParseCommandLineOptions(argc, argv);
-
-  llvm::SmallVector<llvm::StringRef, 4> cxx_flags(CXXFlags.begin(),
-                                                  CXXFlags.end());
-  fs::path dir = SrcDir.getValue();
-  llvm::json::Object root;
-  for (const char *name : {"src.c", "src.cpp"}) {
-    auto path = dir / name;
-    if (!fs::exists(path)) {
-      continue;
-    }
-    llvm::errs() << "Preprocessing " << path.string() << '\n';
-    llvm::json::Object file_root;
-    cpp2rust::Extract(path, file_root, cxx_flags);
-    for (auto &[k, v] : file_root) {
-      if (!root.try_emplace(k, std::move(v)).second) {
-        llvm::errs() << "ERROR: rule name " << k.str()
-                     << " defined in multiple files in " << dir.string()
-                     << '\n';
-        return EXIT_FAILURE;
-      }
-    }
-  }
-
-  fs::path out_path = OutPath.getValue();
-  std::error_code ec;
-  llvm::raw_fd_ostream out(out_path.string(), ec);
-  if (ec) {
-    llvm::errs() << "ERROR: failed to open " << out_path.string() << ": "
-                 << ec.message() << '\n';
-    return EXIT_FAILURE;
-  }
-  out << llvm::formatv("{0:2}", llvm::json::Value(std::move(root))) << '\n';
-  return EXIT_SUCCESS;
-}

From 6872f5258458f18bbed1cc426d590e31c864d711 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:40:53 +0100
Subject: [PATCH 06/34] Update mapper

---
 cpp2rust/converter/mapper.cpp | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/cpp2rust/converter/mapper.cpp b/cpp2rust/converter/mapper.cpp
index 1fe6c4c0d0..4b8189531d 100644
--- a/cpp2rust/converter/mapper.cpp
+++ b/cpp2rust/converter/mapper.cpp
@@ -29,7 +29,7 @@ bool Contains(clang::ASTContext &ctx, const clang::Expr *expr) {
 std::string MapFunctionName(clang::ASTContext &ctx,
                             const clang::FunctionDecl *decl) {
   assert(decl);
-  if (!IsUserDefinedDecl(decl) && Matcher::HasRuleNamed(ctx, decl)) {
+  if (!IsUserDefinedDecl(decl) && Matcher::HasRuleNamed(decl)) {
     return std::format("libcc2rs::{}_{}", decl->getNameAsString(),
                        RuleRegistry::CurrentModel() == Model::kRefCount
                            ? "refcount"
@@ -45,18 +45,13 @@ std::string InstantiateTemplate(clang::ASTContext &ctx, const clang::Expr *expr,
   if (!rule) {
     return text;
   }
-  auto &ty = subs.at(n - 1);
-  if (ty) {
-    ty = Matcher::MapBinding(subs, n - 1);
-  }
-  return Matcher::InstantiateTgt(subs, text);
+  return Matcher::MapBinding(ctx, subs, n - 1);
 }
 
 std::string Map(clang::ASTContext &ctx, clang::QualType qual_type) {
   auto [rule, subs] = RuleRegistry::Search(ctx, qual_type);
   if (rule) {
-    return Matcher::InstantiateTgt(Matcher::MapBindings(subs),
-                                   rule->type_info.type);
+    return Matcher::InstantiateTgt(ctx, subs, rule->type_info.type);
   }
   return {};
 }
@@ -64,8 +59,7 @@ std::string Map(clang::ASTContext &ctx, clang::QualType qual_type) {
 std::string MapInitializer(clang::ASTContext &ctx, clang::QualType qual_type) {
   auto [rule, subs] = RuleRegistry::Search(ctx, qual_type);
   if (rule && !rule->initializer.empty()) {
-    return Matcher::InstantiateTgt(Matcher::MapBindings(subs),
-                                   rule->initializer);
+    return Matcher::InstantiateTgt(ctx, subs, rule->initializer);
   }
   return {};
 }
@@ -73,8 +67,7 @@ std::string MapInitializer(clang::ASTContext &ctx, clang::QualType qual_type) {
 std::string GetParamType(clang::ASTContext &ctx, const clang::Expr *expr,
                          unsigned index) {
   auto [rule, subs] = RuleRegistry::Search(ctx, expr);
-  return Matcher::InstantiateTgt(Matcher::MapBindings(subs),
-                                 rule->params.at(index).type);
+  return Matcher::InstantiateTgt(ctx, subs, rule->params.at(index).type);
 }
 
 } // namespace cpp2rust::Mapper

From dc7923e6cdfa3be55de5bedc17a0246a60b6c651 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:47:45 +0100
Subject: [PATCH 07/34] Pass caller to Mapper

---
 cpp2rust/converter/converter.cpp              | 51 ++++++++-----------
 cpp2rust/converter/converter_lib.cpp          |  7 ---
 cpp2rust/converter/converter_lib.h            |  2 -
 .../converter/models/converter_refcount.cpp   |  8 ++-
 4 files changed, 23 insertions(+), 45 deletions(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 8759208d4a..fb99ae9a53 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -681,7 +681,7 @@ bool Converter::TypeDerivesDefault(clang::QualType qual_type) {
 }
 
 bool Converter::IsPassThroughRule(clang::Expr *expr) const {
-  const auto *rule = RuleRegistry::GetExprRule(ctx_, GetCalleeOrExpr(expr));
+  const auto *rule = RuleRegistry::GetExprRule(ctx_, expr);
   return rule && rule->body.size() == 1 &&
          std::holds_alternative<TranslationRule::PlaceholderFragment>(
              rule->body[0]);
@@ -1834,15 +1834,14 @@ bool Converter::VisitCallExpr(clang::CallExpr *expr) {
     return false;
   }
 
-  if (IsImplicitAssignmentCall(expr) &&
-      !Mapper::Contains(ctx_, expr->getCallee())) {
+  if (IsImplicitAssignmentCall(expr) && !Mapper::Contains(ctx_, expr)) {
     auto *call = clang::cast<clang::CXXMemberCallExpr>(expr);
     ConvertAssignment(call->getImplicitObjectArgument(), call->getArg(0), "=");
     return false;
   }
 
-  if (Mapper::Contains(ctx_, expr->getCallee())) {
-    if (RuleRegistry::IsLibcPassthrough(ctx_, GetCalleeOrExpr(expr))) {
+  if (Mapper::Contains(ctx_, expr)) {
+    if (RuleRegistry::IsLibcPassthrough(ctx_, expr)) {
       ConvertGenericCallExpr(expr);
       return false;
     }
@@ -1882,8 +1881,7 @@ bool Converter::VisitCallExpr(clang::CallExpr *expr) {
   }
 
   if (auto *opcall = clang::dyn_cast<clang::CXXOperatorCallExpr>(expr);
-      opcall && !IsUserOperatorCall(opcall) &&
-      !Mapper::Contains(ctx_, expr->getCallee())) {
+      opcall && !IsUserOperatorCall(opcall) && !Mapper::Contains(ctx_, expr)) {
     return ConvertCXXOperatorCallExpr(opcall);
   }
 
@@ -1981,8 +1979,7 @@ Converter::CallInfo Converter::CollectCallInfo(clang::CallExpr *expr) {
       function ? function->getNumParams() : proto->getNumParams();
   info.is_variadic = function ? function->isVariadic() : proto->isVariadic();
   info.is_fn_ptr_call = !function;
-  info.is_libc_passthrough =
-      RuleRegistry::IsLibcPassthrough(ctx_, GetCalleeOrExpr(expr));
+  info.is_libc_passthrough = RuleRegistry::IsLibcPassthrough(ctx_, expr);
 
   for (unsigned i = 0; i < num_named_params && i < num_args; ++i) {
     auto *arg = expr->getArg(i + arg_begin);
@@ -2130,9 +2127,8 @@ void Converter::EmitArgList(const CallInfo &info) {
       case Kind::Inline:
         ConvertParamTy(ca.param_type, ca.expr);
         if (info.is_libc_passthrough) {
-          StrCat(std::format(
-              "as {}",
-              Mapper::GetParamType(ctx_, GetCalleeOrExpr(info.expr), i)));
+          StrCat(
+              std::format("as {}", Mapper::GetParamType(ctx_, info.expr, i)));
         }
         break;
       }
@@ -2224,7 +2220,7 @@ Converter::ConvertCallExpr(clang::CallExpr *expr) {
                                                 )
                ? token::kOne
                : token::kZero);
-  } else if (Mapper::Contains(ctx_, callee)) {
+  } else if (Mapper::Contains(ctx_, expr)) {
     auto **args = expr->getArgs();
     auto num_args = expr->getNumArgs();
     auto ctx = CollectRefBindingTempArgs(expr);
@@ -4889,9 +4885,8 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
   }
 
   if (ph_ctx.declared_in_rule_as_rust_ptr && arg->getType()->isArrayType()) {
-    return std::format(
-        "({} as {})", ConvertFreshPointer(arg),
-        Mapper::GetParamType(ctx_, GetCalleeOrExpr(expr), ph_ctx.arg_idx));
+    return std::format("({} as {})", ConvertFreshPointer(arg),
+                       Mapper::GetParamType(ctx_, expr, ph_ctx.arg_idx));
   }
 
   if (ph_ctx.needs_materialization()) {
@@ -4906,8 +4901,7 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
   }
 
   if (ph_ctx.needs_pointer_receiver()) {
-    auto param_type =
-        Mapper::GetParamType(ctx_, GetCalleeOrExpr(expr), ph_ctx.arg_idx);
+    auto param_type = Mapper::GetParamType(ctx_, expr, ph_ctx.arg_idx);
     return std::format("({} as {})", ConvertFreshObject(arg, param_type),
                        param_type);
   }
@@ -4973,7 +4967,7 @@ std::string Converter::ConvertMappedMethodCall(
 std::string Converter::GetMappedAsString(clang::Expr *expr, clang::Expr **args,
                                          unsigned num_args,
                                          TempMaterializationCtx *ctx) {
-  auto *tgt_ir = RuleRegistry::GetExprRule(ctx_, GetCalleeOrExpr(expr));
+  auto *tgt_ir = RuleRegistry::GetExprRule(ctx_, expr);
   if (!tgt_ir)
     return {};
 
@@ -4997,7 +4991,7 @@ std::string Converter::ConvertIRFragment(
     if (auto *t = std::get_if<TextFragment>(&frag)) {
       result += t->text;
     } else if (auto *g = std::get_if<GenericFragment>(&frag)) {
-      result += Mapper::InstantiateTemplate(ctx_, GetCalleeOrExpr(expr), g->n);
+      result += Mapper::InstantiateTemplate(ctx_, expr, g->n);
     } else if (auto *ph = std::get_if<PlaceholderFragment>(&frag)) {
       auto arg_idx = ph->n;
       assert(arg_idx < all_args.size());
@@ -5014,8 +5008,8 @@ std::string Converter::ConvertIRFragment(
           .is_receiver = is_receiver,
           .is_cpp_ptr = arg->getType()->isPointerType(),
           .maps_to_rust_ptr = RuleRegistry::MapsToPointer(ctx_, arg->getType()),
-          .declared_in_rule_as_rust_ptr = RuleRegistry::ParamIsPointer(
-              ctx_, GetCalleeOrExpr(expr), arg_idx),
+          .declared_in_rule_as_rust_ptr =
+              RuleRegistry::ParamIsPointer(ctx_, expr, arg_idx),
           .is_index_base = ph->is_index_base,
       };
       result += ConvertPlaceholder(expr, arg, ph_ctx);
@@ -5035,7 +5029,7 @@ std::string Converter::ConvertIRFragment(
 std::string
 Converter::ConvertVariadicTail(clang::Expr *expr,
                                const std::vector<clang::Expr *> &all_args) {
-  const auto *tgt_ir = RuleRegistry::GetExprRule(ctx_, GetCalleeOrExpr(expr));
+  const auto *tgt_ir = RuleRegistry::GetExprRule(ctx_, expr);
   unsigned fixed = tgt_ir ? tgt_ir->params.size() : 0;
 
   Buffer buf(*this);
@@ -5054,14 +5048,9 @@ Converter::ConvertVariadicTail(clang::Expr *expr,
 std::string
 Converter::ConvertInitFragment(clang::Expr *expr,
                                const std::vector<clang::Expr *> &all_args) {
-  const auto *tgt_ir = RuleRegistry::GetExprRule(ctx_, GetCalleeOrExpr(expr));
-  assert(tgt_ir && tgt_ir->init_type.valid());
-  auto *callee = clang::cast<clang::CallExpr>(expr)->getDirectCallee();
-  assert(callee);
-  auto type = GetSema()
-                  .getTemplateInstantiationArgs(callee)(tgt_ir->init_type.depth,
-                                                        tgt_ir->init_type.index)
-                  .getAsType();
+  const auto *tgt_ir = RuleRegistry::GetExprRule(ctx_, expr);
+  assert(tgt_ir && tgt_ir->usesInit());
+  auto type = Matcher::GetInitType(ctx_, expr);
 
   Buffer buf(*this);
   ConvertConstructFromArgs(
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index c7f251517a..e16f3d0421 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -1458,13 +1458,6 @@ clang::Expr *GetCallee(clang::CallExpr *expr) {
   return expr->getCallee();
 }
 
-clang::Expr *GetCalleeOrExpr(clang::Expr *expr) {
-  if (auto *call = clang::dyn_cast<clang::CallExpr>(expr)) {
-    return call->getCallee();
-  }
-  return expr;
-}
-
 bool HasReceiver(clang::Expr *expr) {
   if (clang::isa<clang::CXXMemberCallExpr>(expr))
     return true;
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index 53239f83b3..7d36b9201e 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -255,8 +255,6 @@ bool MayCauseBorrowMutError(const clang::Expr *lhs, const clang::Expr *rhs);
 
 bool ArgsMayAlias(const clang::Expr *a, const clang::Expr *b);
 
-clang::Expr *GetCalleeOrExpr(clang::Expr *expr);
-
 bool HasReceiver(clang::Expr *expr);
 
 std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index b6865e10c3..ab3165c413 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -1162,8 +1162,7 @@ bool ConverterRefCount::VisitCallExpr(clang::CallExpr *expr) {
     return false;
   }
 
-  if (IsImplicitAssignmentCall(expr) &&
-      !Mapper::Contains(ctx_, expr->getCallee())) {
+  if (IsImplicitAssignmentCall(expr) && !Mapper::Contains(ctx_, expr)) {
     auto *call = clang::cast<clang::CXXMemberCallExpr>(expr);
     ConvertAssignment(call->getImplicitObjectArgument(), call->getArg(0), "=");
     return false;
@@ -1174,8 +1173,7 @@ bool ConverterRefCount::VisitCallExpr(clang::CallExpr *expr) {
   }
 
   if (auto *opcall = clang::dyn_cast<clang::CXXOperatorCallExpr>(expr);
-      opcall && !IsUserOperatorCall(opcall) &&
-      !Mapper::Contains(ctx_, expr->getCallee())) {
+      opcall && !IsUserOperatorCall(opcall) && !Mapper::Contains(ctx_, expr)) {
     return ConvertCXXOperatorCallExpr(opcall);
   }
 
@@ -2962,7 +2960,7 @@ std::string ConverterRefCount::ConvertMappedMethodCall(
     arg = call->getArg(0);
   }
 
-  auto param_type = Mapper::GetParamType(ctx_, GetCalleeOrExpr(expr), arg_idx);
+  auto param_type = Mapper::GetParamType(ctx_, expr, arg_idx);
 
   if (arg->getType()->isPointerType()) {
     return std::format("{}.with_mut(|__v: {}| __v{})", ConvertPointer(arg),

From a77dfa701edd9a23890b797e7f96f027e8cd1b97 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:53:21 +0100
Subject: [PATCH 08/34] Update registry

---
 cpp2rust/converter/rules/registry.cpp | 83 +++++++++++----------------
 cpp2rust/converter/rules/registry.h   | 14 ++---
 2 files changed, 38 insertions(+), 59 deletions(-)

diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp
index c987c17b90..2484228296 100644
--- a/cpp2rust/converter/rules/registry.cpp
+++ b/cpp2rust/converter/rules/registry.cpp
@@ -20,25 +20,22 @@ namespace {
 Model model_ = Model::kUnsafe;
 bool translation_rules_loaded_ = false;
 
-ExprRuleMap exprs_; // key -> ExprRule
-TypeRuleMap types_; // key -> TypeRule
+std::unordered_map<std::string, TranslationRule::ExprRule> exprs_;
+std::unordered_map<std::string, TranslationRule::TypeRule> types_;
 
-std::unordered_map<std::string, TranslationRule::ExprRule *> exprs_by_name_;
-std::unordered_map<std::string, TranslationRule::TypeRule *> types_by_name_;
+std::unordered_map<const void *, TranslationRule::TypeRule> user_types_;
 
-void AddTypeRule(std::string src, TranslationRule::TypeRule &&rule) {
-  rule.src = std::move(src);
-  auto key = Matcher::Key(rule);
-  types_.emplace(std::move(key), std::move(rule));
+void AddTypeRule(clang::QualType type, TranslationRule::TypeRule &&rule) {
+  user_types_.try_emplace(type.getCanonicalType().getAsOpaquePtr(),
+                          std::move(rule));
 }
 
 void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
   namespace fs = std::filesystem;
   for (const auto &entry : fs::directory_iterator(dir)) {
     const auto &path = entry.path();
-    assert(fs::exists(path / "ir_src.json") &&
-           (fs::exists(path / "ir_unsafe.json") ||
-            fs::exists(path / "ir_refcount.json")));
+    assert(fs::exists(path / "ir_unsafe.json") ||
+           fs::exists(path / "ir_refcount.json"));
     auto [expr_rules, type_rules] = TranslationRule::Load(path, model);
     if (expr_rules.empty() && type_rules.empty()) {
       log() << "No rules found in " << path << '\n';
@@ -46,23 +43,10 @@ void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
     }
     auto module = path.filename().string();
     for (auto &[name, rule] : expr_rules) {
-      auto it = exprs_.emplace(Matcher::Key(rule), std::move(rule));
-      exprs_by_name_[module + '/' + name] = &it->second;
+      exprs_.emplace(module + '/' + name, std::move(rule));
     }
     for (auto &[name, rule] : type_rules) {
-      auto key = Matcher::Key(rule);
-      auto [begin, end] = types_.equal_range(key);
-      for (auto it = begin; it != end; ++it) {
-        if (it->second.src == rule.src) {
-          llvm::errs() << "ERROR: duplicate type rule for C++ type '"
-                       << rule.src << "': maps to both '"
-                       << it->second.type_info.type << "' and '"
-                       << rule.type_info.type << "'\n";
-          std::exit(EXIT_FAILURE);
-        }
-      }
-      auto it = types_.emplace(std::move(key), std::move(rule));
-      types_by_name_[module + '/' + name] = &it->second;
+      types_.emplace(module + '/' + name, std::move(rule));
     }
   }
 }
@@ -78,27 +62,23 @@ GetParamInfo(clang::ASTContext &ctx, const clang::Expr *expr, unsigned index) {
 
 TranslationRule::ExprRule *FindExprRule(const std::string &module,
                                         const std::string &name) {
-  auto it = exprs_by_name_.find(module + '/' + name);
-  return it == exprs_by_name_.end() ? nullptr : it->second;
+  auto it = exprs_.find(module + '/' + name);
+  return it == exprs_.end() ? nullptr : &it->second;
 }
 
 TranslationRule::TypeRule *FindTypeRule(const std::string &module,
                                         const std::string &name) {
-  auto it = types_by_name_.find(module + '/' + name);
-  return it == types_by_name_.end() ? nullptr : it->second;
+  auto it = types_.find(module + '/' + name);
+  return it == types_.end() ? nullptr : &it->second;
 }
 
-std::ranges::subrange<ExprRuleMap::iterator>
-ExprCandidates(const std::string &key) {
-  auto [begin, end] = exprs_.equal_range(key);
-  return {begin, end};
+TranslationRule::TypeRule *FindUserType(clang::QualType type) {
+  auto it = user_types_.find(
+      type.getCanonicalType().getUnqualifiedType().getAsOpaquePtr());
+  return it == user_types_.end() ? nullptr : &it->second;
 }
 
-std::ranges::subrange<TypeRuleMap::iterator>
-TypeCandidates(const std::string &key) {
-  auto [begin, end] = types_.equal_range(key);
-  return {begin, end};
-}
+void ResetUserTypes() { user_types_.clear(); }
 
 Matcher::Match<TranslationRule::ExprRule> Search(clang::ASTContext &ctx,
                                                  const clang::Expr *expr) {
@@ -156,6 +136,9 @@ bool IsLibcPassthrough(clang::ASTContext &ctx, const clang::Expr *expr) {
   if (tgt_ir == nullptr || !tgt_ir->body.empty() || !tgt_ir->is_extern) {
     return false;
   }
+  if (const auto *call = clang::dyn_cast<clang::CallExpr>(expr)) {
+    expr = call->getCallee();
+  }
   const auto *ref =
       clang::dyn_cast<clang::DeclRefExpr>(expr->IgnoreParenImpCasts());
   const auto *decl = ref != nullptr ? ref->getDecl() : nullptr;
@@ -167,10 +150,12 @@ bool IsLibcPassthrough(clang::ASTContext &ctx, const clang::Expr *expr) {
 Model CurrentModel() { return model_; }
 
 void AddRuleForUserDefinedType(clang::ASTContext &ctx, clang::NamedDecl *decl) {
-  auto cpp_name = Printer::ToString(ctx, GetTypeForDecl(ctx, decl));
-  auto rs_name = Printer::ToRustName(cpp_name);
+  auto type = ctx.getCanonicalTagType(llvm::cast<clang::TagDecl>(decl));
+  auto ptr = ctx.getPointerType(type);
+  auto rs_name =
+      Printer::ToRustName(Printer::ToString(ctx, GetTypeForDecl(ctx, decl)));
 
-  AddTypeRule(cpp_name, TranslationRule::TypeRule::Plain(rs_name));
+  AddTypeRule(type, TranslationRule::TypeRule::Plain(rs_name));
 
   if (auto record_decl = llvm::dyn_cast<clang::RecordDecl>(decl)) {
     // Forward declaration
@@ -182,23 +167,23 @@ void AddRuleForUserDefinedType(clang::ASTContext &ctx, clang::NamedDecl *decl) {
       if (cxx_decl->isAbstract()) {
         switch (model_) {
         case Model::kUnsafe:
-          AddTypeRule(cpp_name + " *", TranslationRule::TypeRule::UnsafePtr(
-                                           "*mut dyn " + rs_name));
+          AddTypeRule(
+              ptr, TranslationRule::TypeRule::UnsafePtr("*mut dyn " + rs_name));
           break;
         case Model::kRefCount:
-          AddTypeRule(cpp_name + " *", TranslationRule::TypeRule::RefcountPtr(
-                                           "PtrDyn<dyn " + rs_name + '>'));
+          AddTypeRule(ptr, TranslationRule::TypeRule::RefcountPtr(
+                               "PtrDyn<dyn " + rs_name + '>'));
           break;
         }
       } else {
         switch (model_) {
         case Model::kUnsafe:
-          AddTypeRule(cpp_name + " *",
+          AddTypeRule(ptr,
                       TranslationRule::TypeRule::UnsafePtr("*mut " + rs_name));
           break;
         case Model::kRefCount:
-          AddTypeRule(cpp_name + " *", TranslationRule::TypeRule::RefcountPtr(
-                                           "Ptr<" + rs_name + '>'));
+          AddTypeRule(ptr, TranslationRule::TypeRule::RefcountPtr(
+                               "Ptr<" + rs_name + '>'));
           break;
         }
       }
diff --git a/cpp2rust/converter/rules/registry.h b/cpp2rust/converter/rules/registry.h
index ce01beb506..e5b53feb67 100644
--- a/cpp2rust/converter/rules/registry.h
+++ b/cpp2rust/converter/rules/registry.h
@@ -18,22 +18,16 @@
 #include "converter/translation_rule.h"
 
 namespace cpp2rust::RuleRegistry {
-using ExprRuleMap =
-    std::unordered_multimap<std::string, TranslationRule::ExprRule>;
-using TypeRuleMap =
-    std::unordered_multimap<std::string, TranslationRule::TypeRule>;
-
-std::ranges::subrange<ExprRuleMap::iterator>
-ExprCandidates(const std::string &key);
-std::ranges::subrange<TypeRuleMap::iterator>
-TypeCandidates(const std::string &key);
-
 TranslationRule::ExprRule *FindExprRule(const std::string &module,
                                         const std::string &name);
 
 TranslationRule::TypeRule *FindTypeRule(const std::string &module,
                                         const std::string &name);
 
+TranslationRule::TypeRule *FindUserType(clang::QualType type);
+
+void ResetUserTypes();
+
 Matcher::Match<TranslationRule::ExprRule> Search(clang::ASTContext &ctx,
                                                  const clang::Expr *expr);
 Matcher::Match<TranslationRule::TypeRule> Search(clang::ASTContext &ctx,

From c63f621cf544a92400c2d659570a5e19083299e9 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:53:46 +0100
Subject: [PATCH 09/34] Don't load IR src

---
 cpp2rust/converter/translation_rule.cpp | 113 +-----------------------
 cpp2rust/converter/translation_rule.h   |  18 +---
 2 files changed, 6 insertions(+), 125 deletions(-)

diff --git a/cpp2rust/converter/translation_rule.cpp b/cpp2rust/converter/translation_rule.cpp
index 34c7696c96..ac319282d2 100644
--- a/cpp2rust/converter/translation_rule.cpp
+++ b/cpp2rust/converter/translation_rule.cpp
@@ -184,59 +184,6 @@ void LoadTgtFromIR(ExprRules &exprs, TypeRules &types,
   }
 }
 
-void LoadIrSrc(ExprRules &exprs, TypeRules &types,
-               const std::filesystem::path &json_path) {
-  auto buf = llvm::MemoryBuffer::getFile(json_path.string());
-  if (!buf) {
-    llvm::errs() << "Missing " << json_path << ", run cpp-rule-preprocessor\n";
-    assert(0);
-    return;
-  }
-
-  auto parsed = llvm::json::parse((*buf)->getBuffer());
-  if (!parsed) {
-    llvm::errs() << "Failed to parse IR src JSON: " << json_path << ": "
-                 << llvm::toString(parsed.takeError()) << '\n';
-    assert(0);
-    return;
-  }
-
-  auto *root = parsed->getAsObject();
-  if (!root) {
-    return;
-  }
-
-  for (auto &[entry_name, entry_val] : *root) {
-    auto name = entry_name.str();
-    auto val = entry_val.getAsString();
-    if (name[0] == 'f') {
-      auto it = exprs.find(name);
-      if (it == exprs.end()) {
-        llvm::errs() << name << '\n';
-        assert(0 && "ir_src.json expr entry has no matching IR target rule");
-      }
-      if (auto *obj = entry_val.getAsObject()) {
-        it->second.src = obj->getString("key")->str();
-        auto *init_type = obj->getObject("init_type");
-        assert(init_type && "ir_src.json expr entry object without init_type");
-        it->second.init_type = InitTypeLocation{
-            (unsigned)*init_type->getInteger("depth"),
-            (unsigned)*init_type->getInteger("index"),
-        };
-        continue;
-      }
-      it->second.src = val->str();
-    } else if (name[0] == 't') {
-      auto it = types.find(name);
-      if (it == types.end()) {
-        llvm::errs() << name << '\n';
-        assert(0 && "ir_src.json type entry has no matching IR target rule");
-      }
-      it->second.src = val->str();
-    }
-  }
-}
-
 void BodyFragmentDump(const BodyFragment &frag) {
   if (auto *t = std::get_if<TextFragment>(&frag)) {
     t->dump();
@@ -311,11 +258,6 @@ void MethodCallFragment::dump() const {
 }
 
 void ExprRule::dump() const {
-  log() << "Matching: " << src << '\n';
-  if (init_type.valid()) {
-    log() << "  init type: depth " << init_type.depth << ", index "
-          << init_type.index << '\n';
-  }
   unsigned i = 0;
   for (auto &info : params) {
     log() << "  param a" << i++ << ": ";
@@ -340,46 +282,7 @@ void ExprRule::dump() const {
   }
 }
 
-void ExprRule::validate(const std::string &name) const {
-  if (src.empty()) {
-    llvm::errs() << name << '\n';
-    dump();
-    llvm::report_fatal_error("Expr rule loaded from IR but has no src");
-  }
-
-  if (HasInitFragment(body) && !init_type.valid()) {
-    llvm::errs() << name << '\n';
-    dump();
-    llvm::report_fatal_error(
-        "Expr rule uses init but its src pack is not declared as Init<T, "
-        "Args>");
-  }
-
-  if (generics.empty())
-    return;
-
-  bool has_generic[kMaxGenerics] = {false};
-  for (size_t i = 0, e = src.size(); i < e; ++i) {
-    auto pos = src.find('T', i);
-    if (pos == std::string::npos)
-      break;
-    auto ch = pos + 1 < e ? src[pos + 1] : '\0';
-    if (ch >= '1' && ch <= '9') {
-      has_generic[ch - '1'] = true;
-      i = pos + 1;
-    }
-  }
-
-  for (size_t i = 0, e = generics.size(); i < e; ++i) {
-    if (!has_generic[i]) {
-      llvm::errs() << name << '\n';
-      dump();
-      llvm::errs() << "generic T" << (i + 1)
-                   << " declared but missing from src: " << src << '\n';
-      llvm::report_fatal_error("Absent generic from src");
-    }
-  }
-}
+bool ExprRule::usesInit() const { return HasInitFragment(body); }
 
 void GenericFragment::dump() const { log() << "  generic: " << n << '\n'; }
 
@@ -394,7 +297,7 @@ void TypeInfo::dump() const {
 }
 
 void TypeRule::dump() const {
-  log() << "name: " << src << "\n  Rust type: ";
+  log() << "Rust type: ";
   type_info.dump();
   log() << '\n';
   if (!initializer.empty()) {
@@ -415,18 +318,6 @@ std::pair<ExprRules, TypeRules> Load(const std::filesystem::path &dir,
     }
   }
 
-  LoadIrSrc(exprs, types, dir / "ir_src.json");
-
-  for (auto &[name, rule] : exprs) {
-    rule.validate(name);
-  }
-  for (auto &[name, rule] : types) {
-    if (rule.src.empty()) {
-      llvm::errs() << name << '\n';
-      rule.dump();
-      assert(0 && "Type rule loaded from IR but has no src");
-    }
-  }
   return {std::move(exprs), std::move(types)};
 }
 
diff --git a/cpp2rust/converter/translation_rule.h b/cpp2rust/converter/translation_rule.h
index 8d6846ef8e..27b9b1c9e9 100644
--- a/cpp2rust/converter/translation_rule.h
+++ b/cpp2rust/converter/translation_rule.h
@@ -72,16 +72,7 @@ struct TypeInfo {
   void dump() const;
 };
 
-struct InitTypeLocation {
-  unsigned depth = -1u;
-  unsigned index = -1u;
-
-  bool valid() const { return depth != -1u; }
-};
-
 struct ExprRule {
-  std::string src;
-  InitTypeLocation init_type;
   std::vector<TypeInfo> params;
   TypeInfo return_type;
   std::vector<std::vector<std::string>> generics; // "T1" -> ["Ord", "Clone"]
@@ -90,24 +81,23 @@ struct ExprRule {
   bool is_extern = false;
 
   void dump() const;
-  void validate(const std::string &name) const;
+  bool usesInit() const;
 };
 
 struct TypeRule {
-  std::string src;
   std::string initializer; // Rust initializer expression
   TypeInfo type_info;
 
   void dump() const;
 
   static TypeRule Plain(std::string type) {
-    return {{}, {}, {{}, std::move(type), false, false}};
+    return {{}, {{}, std::move(type), false, false}};
   }
   static TypeRule RefcountPtr(std::string type) {
-    return {{}, {}, {{}, std::move(type), true, false}};
+    return {{}, {{}, std::move(type), true, false}};
   }
   static TypeRule UnsafePtr(std::string type) {
-    return {{}, {}, {{}, std::move(type), false, true}};
+    return {{}, {{}, std::move(type), false, true}};
   }
 };
 

From ad965a9e68fa55a11ffeda655899504d04095c81 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:55:05 +0100
Subject: [PATCH 10/34] Update rule decls

---
 cpp2rust/converter/rules/rule_decls.cpp | 244 +++++++++++++++++++++---
 cpp2rust/converter/rules/rule_decls.h   |  21 +-
 2 files changed, 234 insertions(+), 31 deletions(-)

diff --git a/cpp2rust/converter/rules/rule_decls.cpp b/cpp2rust/converter/rules/rule_decls.cpp
index 9bf69f4ae3..c1cb940708 100644
--- a/cpp2rust/converter/rules/rule_decls.cpp
+++ b/cpp2rust/converter/rules/rule_decls.cpp
@@ -15,6 +15,7 @@
 #include <optional>
 #include <string_view>
 
+#include "converter/printer.h"
 #include "converter/rules/registry.h"
 #include "logging.h"
 #include "rules_prelude.h"
@@ -27,6 +28,9 @@ constexpr std::string_view kPrefix = "cpp2rust_rules_";
 
 ExprRuleDeclMap exprs_;
 TypeRuleDeclMap types_;
+std::unordered_map<const void *, TranslationRule::TypeRule *> plain_types_;
+std::unordered_map<std::string, TranslationRule::TypeRule *> alias_types_;
+clang::Sema *sema_ = nullptr;
 
 bool isRuleName(std::string_view name, char kind) {
   return name.size() > 1 && name[0] == kind &&
@@ -37,21 +41,28 @@ bool isRuleName(std::string_view name, char kind) {
 struct RuleId {
   std::string module;
   std::string name;
+  bool native = true;
 };
 
 std::optional<RuleId> getRuleId(const clang::NamedDecl *decl) {
   if (!decl->getIdentifier()) {
     return std::nullopt;
   }
+  constexpr std::string_view kOther = "other";
   std::string_view name = decl->getName();
   if (const auto *ns =
           llvm::dyn_cast<clang::NamespaceDecl>(decl->getDeclContext())) {
-    std::string_view module = ns->getIdentifier() ? ns->getName() : "";
+    bool native = true;
+    if (ns->getIdentifier() && std::string_view(ns->getName()) == kOther) {
+      native = false;
+      ns = llvm::dyn_cast<clang::NamespaceDecl>(ns->getDeclContext());
+    }
+    std::string_view module = ns && ns->getIdentifier() ? ns->getName() : "";
     if (!module.starts_with(kPrefix)) {
       return std::nullopt;
     }
-    return RuleId{std::string(module.substr(kPrefix.size())),
-                  std::string(name)};
+    return RuleId{std::string(module.substr(kPrefix.size())), std::string(name),
+                  native};
   }
   if (!name.starts_with(kPrefix)) {
     return std::nullopt;
@@ -61,11 +72,18 @@ std::optional<RuleId> getRuleId(const clang::NamedDecl *decl) {
   if (split == std::string_view::npos) {
     return std::nullopt;
   }
-  return RuleId{std::string(name.substr(0, split)),
-                std::string(name.substr(split + 1))};
+  auto module = name.substr(0, split);
+  bool native = !module.ends_with("_other");
+  if (!native) {
+    module.remove_suffix(kOther.size() + 1);
+  }
+  return RuleId{std::string(module), std::string(name.substr(split + 1)),
+                native};
 }
 
-const clang::Expr *getReturned(const clang::FunctionDecl *decl) {
+} // namespace
+
+const clang::Expr *GetReturned(const clang::FunctionDecl *decl) {
   const auto *body =
       llvm::dyn_cast_or_null<clang::CompoundStmt>(decl->getBody());
   if (!body || body->size() != 1) {
@@ -75,6 +93,8 @@ const clang::Expr *getReturned(const clang::FunctionDecl *decl) {
   return ret ? ret->getRetValue() : nullptr;
 }
 
+namespace {
+
 std::string getOperatorKey(clang::OverloadedOperatorKind op) {
   if (op == clang::OO_None) {
     return {};
@@ -96,7 +116,9 @@ std::string getNameKey(clang::DeclarationName name) {
   }
 }
 
-std::string getTypeKey(clang::QualType type) {
+} // namespace
+
+std::string GetTypeKey(clang::QualType type) {
   type = type.getNonReferenceType();
   if (const auto *tst = type->getAs<clang::TemplateSpecializationType>()) {
     if (const auto *tmpl = tst->getTemplateName().getAsTemplateDecl()) {
@@ -109,7 +131,36 @@ std::string getTypeKey(clang::QualType type) {
   return {};
 }
 
-const clang::Expr *skipImplicit(const clang::Expr *expr) {
+std::string GetAliasKey(clang::QualType type) {
+  type = type.getUnqualifiedType();
+  if (const auto *decltype_type =
+          llvm::dyn_cast<clang::DecltypeType>(type.getTypePtr())) {
+    type = decltype_type->getUnderlyingType().getUnqualifiedType();
+  }
+  if (const auto *typeof_type =
+          llvm::dyn_cast<clang::TypeOfExprType>(type.getTypePtr())) {
+    type = typeof_type->desugar().getUnqualifiedType();
+  }
+  if (const auto *typedef_type = type->getAs<clang::TypedefType>();
+      typedef_type && type.getCanonicalType()->isBuiltinType()) {
+    return typedef_type->getDecl()->getName().str();
+  }
+  if (const auto *predefined = type->getAs<clang::PredefinedSugarType>()) {
+    return predefined->getIdentifier()->getName().str();
+  }
+  if (const auto *pointer = type->getAs<clang::PointerType>()) {
+    auto pointee = pointer->getPointeeType();
+    auto key = GetAliasKey(pointee);
+    if (key.empty()) {
+      return {};
+    }
+    return std::string(pointee.isConstQualified() ? "const " : "") +
+           (pointee.isVolatileQualified() ? "volatile " : "") + key + " *";
+  }
+  return {};
+}
+
+const clang::Expr *SkipImplicit(const clang::Expr *expr) {
   while (true) {
     expr = expr->IgnoreParens();
     if (const auto *full = llvm::dyn_cast<clang::FullExpr>(expr)) {
@@ -130,16 +181,11 @@ const clang::Expr *skipImplicit(const clang::Expr *expr) {
       return expr;
     }
     expr = cast->getSubExpr();
-    if (cast->getCastKind() != clang::CK_UserDefinedConversion) {
-      continue;
-    }
-    if (const auto *conversion =
-            llvm::dyn_cast<clang::CXXMemberCallExpr>(expr->IgnoreImplicit())) {
-      expr = conversion->getImplicitObjectArgument();
-    }
   }
 }
 
+namespace {
+
 bool isDeclaredByRules(clang::ASTContext &ctx, const clang::Decl *decl) {
   auto &src_mgr = ctx.getSourceManager();
   return IsRulesPrelude(src_mgr.getFilename(
@@ -147,11 +193,11 @@ bool isDeclaredByRules(clang::ASTContext &ctx, const clang::Decl *decl) {
 }
 
 bool refersToUndeclared(const clang::Expr *expr) {
-  expr = skipImplicit(expr);
+  expr = SkipImplicit(expr);
   if (const auto *call = llvm::dyn_cast<clang::CallExpr>(expr)) {
     if (const auto *lookup = llvm::dyn_cast<clang::UnresolvedLookupExpr>(
             call->getCallee()->IgnoreParenImpCasts())) {
-      return lookup->getNumDecls() == 0;
+      return lookup->getName().isIdentifier() && lookup->getNumDecls() == 0;
     }
     if (const auto *callee = call->getDirectCallee()) {
       return callee->isImplicit() && !callee->getBuiltinID();
@@ -168,8 +214,10 @@ bool refersToUndeclared(clang::ASTContext &ctx, clang::QualType type) {
   return tag && isDeclaredByRules(ctx, tag);
 }
 
-std::string getExprKey(clang::ASTContext &ctx, const clang::Expr *expr) {
-  expr = skipImplicit(expr);
+} // namespace
+
+std::string GetExprKey(clang::ASTContext &ctx, const clang::Expr *expr) {
+  expr = SkipImplicit(expr);
 
   if (llvm::isa<clang::IntegerLiteral>(expr) &&
       expr->getBeginLoc().isMacroID()) {
@@ -191,7 +239,7 @@ std::string getExprKey(clang::ASTContext &ctx, const clang::Expr *expr) {
         ref && llvm::isa<clang::ParmVarDecl>(ref->getDecl())) {
       return getOperatorKey(clang::OO_Call);
     }
-    return getExprKey(ctx, callee);
+    return GetExprKey(ctx, callee);
   }
   if (const auto *overload = llvm::dyn_cast<clang::OverloadExpr>(expr)) {
     return getNameKey(overload->getName());
@@ -215,7 +263,7 @@ std::string getExprKey(clang::ASTContext &ctx, const clang::Expr *expr) {
       return getOperatorKey(
           clang::UnaryOperator::getOverloadedOperator(unary->getOpcode()));
     }
-    return getExprKey(ctx, unary->getSubExpr());
+    return GetExprKey(ctx, unary->getSubExpr());
   }
   if (const auto *binary = llvm::dyn_cast<clang::BinaryOperator>(expr)) {
     return getOperatorKey(
@@ -226,22 +274,94 @@ std::string getExprKey(clang::ASTContext &ctx, const clang::Expr *expr) {
   }
   if (const auto *construct =
           llvm::dyn_cast<clang::CXXUnresolvedConstructExpr>(expr)) {
-    return getTypeKey(construct->getTypeAsWritten());
+    return GetTypeKey(construct->getTypeAsWritten());
   }
   if (const auto *construct = llvm::dyn_cast<clang::CXXConstructExpr>(expr)) {
     return getNameKey(construct->getConstructor()->getParent()->getDeclName());
   }
   if (const auto *cast = llvm::dyn_cast<clang::ExplicitCastExpr>(expr)) {
-    return getTypeKey(cast->getTypeAsWritten());
+    return GetTypeKey(cast->getTypeAsWritten());
   }
   return {};
 }
 
+namespace {
+
+unsigned getGenericNumber(const clang::NamedDecl *param) {
+  auto name = param->getName();
+  unsigned n = 0;
+  if (!name.consume_front("T") || name.getAsInteger(10, n)) {
+    return 0;
+  }
+  return n;
+}
+
+clang::QualType getInitType(const clang::FunctionDecl *function) {
+  if (function->param_empty()) {
+    return {};
+  }
+  const auto *expansion = function->parameters()
+                              .back()
+                              ->getType()
+                              ->getAs<clang::PackExpansionType>();
+  if (!expansion) {
+    return {};
+  }
+  const auto *alias = expansion->getPattern()
+                          .getNonReferenceType()
+                          ->getAs<clang::TemplateSpecializationType>();
+  if (!alias || !alias->isTypeAlias() ||
+      alias->getTemplateName().getAsTemplateDecl()->getName() != "Init") {
+    return {};
+  }
+  return alias->template_arguments()[0].getAsType();
+}
+
+void checkGenerics(const RuleId &id, const clang::FunctionDecl *function,
+                   const TranslationRule::ExprRule &rule) {
+  bool declared[TranslationRule::kMaxGenerics + 1] = {false};
+  if (const auto *tmpl = function->getDescribedFunctionTemplate()) {
+    for (const auto *param : *tmpl->getTemplateParameters()) {
+      auto n = getGenericNumber(param);
+      assert(n <= TranslationRule::kMaxGenerics &&
+             "template placeholder exceeds kMaxGenerics");
+      declared[n] = true;
+    }
+  }
+  for (size_t i = 0, e = rule.generics.size(); i < e; ++i) {
+    if (!declared[i + 1]) {
+      llvm::errs() << id.module << "::" << id.name << ": generic T" << (i + 1)
+                   << " declared but missing from src\n";
+      llvm::report_fatal_error("Absent generic from src");
+    }
+  }
+  if (rule.usesInit() && getInitType(function).isNull()) {
+    llvm::errs() << id.module << "::" << id.name << '\n';
+    llvm::report_fatal_error(
+        "Expr rule uses init but its src pack is not declared as Init<T, "
+        "Args>");
+  }
+}
+
 void addExprRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
   auto id = getRuleId(decl);
   if (!id || !isRuleName(id->name, 'f')) {
     return;
   }
+  if (const auto *var = llvm::dyn_cast<clang::VarDecl>(decl)) {
+    const auto *init = var->getInit();
+    auto *rule = RuleRegistry::FindExprRule(id->module, id->name);
+    if (var->isInvalidDecl() || !init || init->containsErrors() || !rule) {
+      log() << "rule " << id->module << "::" << id->name << " does not apply\n";
+      return;
+    }
+    auto key = GetExprKey(ctx, init);
+    log() << "rule " << id->module << "::" << id->name << " -> '" << key
+          << "'\n";
+    exprs_.emplace(std::move(key),
+                   ExprRuleDecl{nullptr, init, rule, id->native, {}});
+    return;
+  }
   const clang::FunctionDecl *function = nullptr;
   if (const auto *tmpl = llvm::dyn_cast<clang::FunctionTemplateDecl>(decl)) {
     function = tmpl->getTemplatedDecl();
@@ -251,7 +371,7 @@ void addExprRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
   if (!function || !function->isThisDeclarationADefinition()) {
     return;
   }
-  const auto *returned = getReturned(function);
+  const auto *returned = GetReturned(function);
   if (decl->isInvalidDecl() || function->isInvalidDecl() || !returned ||
       returned->containsErrors() || refersToUndeclared(returned)) {
     log() << "rule " << id->module << "::" << id->name << " does not apply\n";
@@ -262,9 +382,12 @@ void addExprRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
     log() << "rule " << id->module << "::" << id->name << " has no target\n";
     return;
   }
-  auto key = getExprKey(ctx, returned);
+  checkGenerics(*id, function, *rule);
+  auto key = GetExprKey(ctx, returned);
   log() << "rule " << id->module << "::" << id->name << " -> '" << key << "'\n";
-  exprs_.emplace(std::move(key), ExprRuleDecl{function, rule});
+  exprs_.emplace(std::move(key),
+                 ExprRuleDecl{function, returned, rule, id->native,
+                              getInitType(function)});
 }
 
 void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
@@ -272,6 +395,13 @@ void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
   if (!id || !isRuleName(id->name, 't')) {
     return;
   }
+  if (llvm::isa<clang::FunctionTemplateDecl>(decl)) {
+    if (auto *rule = RuleRegistry::FindTypeRule(id->module, id->name)) {
+      log() << "rule " << id->module << "::" << id->name << " -> ''\n";
+      types_.emplace("", TypeRuleDecl{decl, rule});
+    }
+    return;
+  }
   const clang::TypedefNameDecl *alias = nullptr;
   if (const auto *tmpl = llvm::dyn_cast<clang::TypeAliasTemplateDecl>(decl)) {
     alias = tmpl->getTemplatedDecl();
@@ -292,7 +422,29 @@ void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
     log() << "rule " << id->module << "::" << id->name << " has no target\n";
     return;
   }
-  auto key = getTypeKey(alias->getUnderlyingType());
+  if (!llvm::isa<clang::TypeAliasTemplateDecl>(decl)) {
+    log() << "rule " << id->module << "::" << id->name << " is a plain type\n";
+    auto add = [&](auto &types, auto key) {
+      auto [it, inserted] = types.try_emplace(std::move(key), rule);
+      if (!inserted && it->second != rule) {
+        llvm::errs() << "ERROR: duplicate type rule for C++ type '"
+                     << Printer::ToString(ctx, alias->getUnderlyingType())
+                     << "': maps to both '" << it->second->type_info.type
+                     << "' and '" << rule->type_info.type << "'\n";
+        std::exit(EXIT_FAILURE);
+      }
+    };
+    if (auto key = GetAliasKey(alias->getUnderlyingType()); !key.empty()) {
+      add(alias_types_, std::move(key));
+      return;
+    }
+    add(plain_types_, alias->getUnderlyingType()
+                          .getCanonicalType()
+                          .getUnqualifiedType()
+                          .getAsOpaquePtr());
+    return;
+  }
+  auto key = GetTypeKey(alias->getUnderlyingType());
   log() << "rule " << id->module << "::" << id->name << " -> '" << key << "'\n";
   types_.emplace(std::move(key), TypeRuleDecl{decl, rule});
 }
@@ -300,7 +452,9 @@ void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
 void addRules(clang::ASTContext &ctx, const clang::DeclContext *context) {
   for (const auto *child : context->decls()) {
     if (const auto *ns = llvm::dyn_cast<clang::NamespaceDecl>(child)) {
-      if (ns->getIdentifier() && ns->getName().starts_with(kPrefix)) {
+      if (ns->getIdentifier() && (ns->getName().starts_with(kPrefix) ||
+                                  (ns->getName() == "other" &&
+                                   context != ctx.getTranslationUnitDecl()))) {
         addRules(ctx, ns);
       }
       continue;
@@ -314,12 +468,42 @@ void addRules(clang::ASTContext &ctx, const clang::DeclContext *context) {
 
 } // namespace
 
-void Collect(clang::ASTContext &ctx) {
+clang::Sema &GetSema() {
+  assert(sema_);
+  return *sema_;
+}
+
+void Collect(clang::Sema &sema) {
+  auto &ctx = sema.Context;
+  sema_ = &sema;
   exprs_.clear();
   types_.clear();
+  plain_types_.clear();
+  alias_types_.clear();
   addRules(ctx, ctx.getTranslationUnitDecl());
   log() << "collected " << exprs_.size() << " expression rules and "
-        << types_.size() << " type rules\n";
+        << types_.size() + plain_types_.size() + alias_types_.size()
+        << " type rules\n";
+}
+
+TranslationRule::TypeRule *FindPlainType(clang::QualType type) {
+  for (auto alias = type;;) {
+    auto key = GetAliasKey(alias);
+    if (key.empty()) {
+      break;
+    }
+    if (auto it = alias_types_.find(key); it != alias_types_.end()) {
+      return it->second;
+    }
+    const auto *typedef_type = alias->getAs<clang::TypedefType>();
+    if (!typedef_type) {
+      break;
+    }
+    alias = typedef_type->desugar();
+  }
+  auto it = plain_types_.find(
+      type.getCanonicalType().getUnqualifiedType().getAsOpaquePtr());
+  return it == plain_types_.end() ? nullptr : it->second;
 }
 
 std::ranges::subrange<ExprRuleDeclMap::iterator>
diff --git a/cpp2rust/converter/rules/rule_decls.h b/cpp2rust/converter/rules/rule_decls.h
index 12f8eaa483..617b284b7a 100644
--- a/cpp2rust/converter/rules/rule_decls.h
+++ b/cpp2rust/converter/rules/rule_decls.h
@@ -5,6 +5,8 @@
 
 #include <clang/AST/ASTContext.h>
 #include <clang/AST/Decl.h>
+#include <clang/AST/Expr.h>
+#include <clang/Sema/Sema.h>
 
 #include <ranges>
 #include <string>
@@ -15,7 +17,10 @@
 namespace cpp2rust::RuleDecls {
 struct ExprRuleDecl {
   const clang::FunctionDecl *decl;
+  const clang::Expr *returned;
   TranslationRule::ExprRule *rule;
+  bool native;
+  clang::QualType init_type;
 };
 
 struct TypeRuleDecl {
@@ -26,7 +31,21 @@ struct TypeRuleDecl {
 using ExprRuleDeclMap = std::unordered_multimap<std::string, ExprRuleDecl>;
 using TypeRuleDeclMap = std::unordered_multimap<std::string, TypeRuleDecl>;
 
-void Collect(clang::ASTContext &ctx);
+void Collect(clang::Sema &sema);
+
+clang::Sema &GetSema();
+
+const clang::Expr *GetReturned(const clang::FunctionDecl *decl);
+
+const clang::Expr *SkipImplicit(const clang::Expr *expr);
+
+std::string GetExprKey(clang::ASTContext &ctx, const clang::Expr *expr);
+
+std::string GetTypeKey(clang::QualType type);
+
+std::string GetAliasKey(clang::QualType type);
+
+TranslationRule::TypeRule *FindPlainType(clang::QualType type);
 
 std::ranges::subrange<ExprRuleDeclMap::iterator>
 ExprCandidates(const std::string &key);

From 9a7883f9a31514f268491a6ace099af373094b0c Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:55:54 +0100
Subject: [PATCH 11/34] Stop checking for ir_src.json

---
 cpp2rust/cpp2rust.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp2rust/cpp2rust.cpp b/cpp2rust/cpp2rust.cpp
index d8ffcb7472..7631b877cf 100644
--- a/cpp2rust/cpp2rust.cpp
+++ b/cpp2rust/cpp2rust.cpp
@@ -94,8 +94,8 @@ static bool HasIRFiles(const fs::path &dir) {
       continue;
     }
     const auto &p = it->path();
-    if (fs::exists(p / "ir_src.json") && (fs::exists(p / "ir_unsafe.json") ||
-                                          fs::exists(p / "ir_refcount.json"))) {
+    if (fs::exists(p / "ir_unsafe.json") ||
+        fs::exists(p / "ir_refcount.json")) {
       return true;
     }
   }

From 5f1b2e33c7b940be6badcfc6983e012a08c93581 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:56:07 +0100
Subject: [PATCH 12/34] Update rules prelude

---
 cpp2rust/rules_prelude.cpp | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/cpp2rust/rules_prelude.cpp b/cpp2rust/rules_prelude.cpp
index 83bc5e59e3..480c4885af 100644
--- a/cpp2rust/rules_prelude.cpp
+++ b/cpp2rust/rules_prelude.cpp
@@ -89,15 +89,16 @@ void addCxxModule(std::string &out, const fs::path &module_dir) {
   out += std::format("namespace cpp2rust_rules_{} {{\n",
                      module_dir.filename().string());
   out += withoutIncludes(readFile(module_dir / "src.cpp"));
-  out += "}\n";
+  out += "namespace other {\n";
+  out += withoutIncludes(readFile(module_dir / "src.c"));
+  out += "}\n}\n";
 }
 
-void addCModule(std::string &out, const fs::path &module_dir) {
-  auto module = module_dir.filename().string();
-  auto text = readFile(module_dir / "src.c");
+void addCRules(std::string &out, const std::string &prefix,
+               const std::string &text) {
   auto names = getRuleNames(text);
   for (const auto &name : names) {
-    out += std::format("#define {} cpp2rust_rules_{}_{}\n", name, module, name);
+    out += std::format("#define {} {}_{}\n", name, prefix, name);
   }
   out += withoutIncludes(text);
   for (const auto &name : names) {
@@ -105,6 +106,12 @@ void addCModule(std::string &out, const fs::path &module_dir) {
   }
 }
 
+void addCModule(std::string &out, const fs::path &module_dir) {
+  auto prefix = "cpp2rust_rules_" + module_dir.filename().string();
+  addCRules(out, prefix, readFile(module_dir / "src.c"));
+  addCRules(out, prefix + "_other", readFile(module_dir / "src.cpp"));
+}
+
 } // namespace
 
 RulesLanguage GetRulesLanguage(std::string_view filename) {
@@ -137,10 +144,9 @@ std::string BuildRulesPrelude(RulesLanguage language) {
 
   std::string out = "#pragma GCC system_header\n";
   for (const auto &module_dir : modules) {
-    if (language == RulesLanguage::kCxx && fs::exists(module_dir / "src.cpp")) {
+    if (language == RulesLanguage::kCxx) {
       addCxxModule(out, module_dir);
-    }
-    if (language == RulesLanguage::kC && fs::exists(module_dir / "src.c")) {
+    } else {
       addCModule(out, module_dir);
     }
   }

From fac7c1f42fa520924c0ffd4228e0098a8f596e1f Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 21:56:28 +0100
Subject: [PATCH 13/34] Add AST matcher

---
 cpp2rust/ast_consumer.cpp            |   5 +-
 cpp2rust/converter/rules/matcher.cpp | 571 ++++++++++++++++++++++++++-
 cpp2rust/converter/rules/matcher.h   |  16 +-
 3 files changed, 571 insertions(+), 21 deletions(-)

diff --git a/cpp2rust/ast_consumer.cpp b/cpp2rust/ast_consumer.cpp
index 5b225ae017..07e72ee9e4 100644
--- a/cpp2rust/ast_consumer.cpp
+++ b/cpp2rust/ast_consumer.cpp
@@ -4,12 +4,15 @@
 #include "ast_consumer.h"
 
 #include "converter/converter.h"
+#include "converter/rules/matcher.h"
+#include "converter/rules/registry.h"
 #include "converter/rules/rule_decls.h"
 
 namespace cpp2rust {
 void ASTConsumer::HandleTranslationUnit(clang::ASTContext &ctx) {
   auto converter = CreateConverter(rs_code_, ctx, model_, rules_dir_);
-  RuleDecls::Collect(ctx);
+  RuleDecls::Collect(CI_.getSema());
+  RuleRegistry::ResetUserTypes();
   converter->SetSema(CI_.getSema());
   if (first_) {
     converter->EmitFilePreamble();
diff --git a/cpp2rust/converter/rules/matcher.cpp b/cpp2rust/converter/rules/matcher.cpp
index 1dd53121f1..184e878873 100644
--- a/cpp2rust/converter/rules/matcher.cpp
+++ b/cpp2rust/converter/rules/matcher.cpp
@@ -3,30 +3,579 @@
 
 #include "converter/rules/matcher.h"
 
+#include <clang/AST/DeclCXX.h>
+#include <clang/AST/DeclTemplate.h>
+#include <clang/AST/ExprCXX.h>
+#include <clang/AST/ParentMapContext.h>
+#include <clang/Lex/Lexer.h>
+#include <clang/Sema/EnterExpressionEvaluationContext.h>
+#include <clang/Sema/Sema.h>
+#include <clang/Sema/Template.h>
+#include <clang/Sema/TemplateDeduction.h>
+
 #include <cassert>
 #include <cctype>
+#include <vector>
+
+#include "converter/converter_lib.h"
+#include "converter/mapper.h"
+#include "converter/printer.h"
+#include "converter/rules/registry.h"
+#include "converter/rules/rule_decls.h"
+#include "logging.h"
 
 namespace cpp2rust::Matcher {
 
-Bindings MapBindings(const Bindings &bindings) {
-  Bindings mapped(bindings.size());
-  for (unsigned i = 0; i < bindings.size(); ++i) {
-    if (bindings[i]) {
-      mapped[i] = MapBinding(bindings, i);
+namespace {
+
+using ExprMatch = Match<TranslationRule::ExprRule>;
+using TypeMatch = Match<TranslationRule::TypeRule>;
+
+struct Target {
+  const clang::Decl *decl = nullptr;
+  std::string macro;
+  int unary = -1;
+  int spelled = -1;
+
+  bool operator==(const Target &) const = default;
+  explicit operator bool() const { return decl || !macro.empty(); }
+};
+
+Target getTarget(clang::ASTContext &ctx, const clang::Expr *expr) {
+  expr = RuleDecls::SkipImplicit(expr);
+
+  if (llvm::isa<clang::IntegerLiteral>(expr) &&
+      expr->getBeginLoc().isMacroID()) {
+    Target target;
+    target.macro = clang::Lexer::getImmediateMacroName(expr->getBeginLoc(),
+                                                       ctx.getSourceManager(),
+                                                       ctx.getLangOpts())
+                       .str();
+    return target;
+  }
+  if (const auto *rewritten =
+          llvm::dyn_cast<clang::CXXRewrittenBinaryOperator>(expr)) {
+    auto target = getTarget(ctx, rewritten->getSemanticForm());
+    target.spelled = rewritten->getOperator();
+    return target;
+  }
+  if (const auto *unary = llvm::dyn_cast<clang::UnaryOperator>(expr)) {
+    auto target = getTarget(ctx, unary->getSubExpr());
+    target.unary = unary->getOpcode();
+    return target;
+  }
+  Target target;
+  if (const auto *call = llvm::dyn_cast<clang::CallExpr>(expr)) {
+    if (const auto *callee = call->getDirectCallee()) {
+      target.decl = callee->getCanonicalDecl();
+    }
+  } else if (const auto *construct =
+                 llvm::dyn_cast<clang::CXXConstructExpr>(expr)) {
+    target.decl = construct->getConstructor()->getCanonicalDecl();
+  } else if (const auto *member = llvm::dyn_cast<clang::MemberExpr>(expr)) {
+    target.decl = member->getMemberDecl()->getCanonicalDecl();
+  } else if (const auto *ref = llvm::dyn_cast<clang::DeclRefExpr>(expr)) {
+    target.decl = ref->getDecl()->getCanonicalDecl();
+  } else if (const auto *cast = llvm::dyn_cast<clang::ExplicitCastExpr>(expr)) {
+    return getTarget(ctx, cast->getSubExpr());
+  }
+  return target;
+}
+
+clang::Expr *getObject(clang::ASTContext &ctx, clang::Expr *object) {
+  auto type = object->getType();
+  if (type->isPointerType()) {
+    type = type->getPointeeType();
+  } else if (!type.isConstQualified()) {
+    return object;
+  }
+  return new (ctx) clang::OpaqueValueExpr(
+      object->getBeginLoc(), type.getUnqualifiedType(), clang::VK_LValue);
+}
+
+std::vector<clang::Expr *> getOperands(clang::ASTContext &ctx,
+                                       const clang::Expr *use) {
+  auto *expr = const_cast<clang::Expr *>(use);
+  std::vector<clang::Expr *> operands;
+  if (auto *rewritten =
+          llvm::dyn_cast<clang::CXXRewrittenBinaryOperator>(expr)) {
+    auto decomposed = rewritten->getDecomposedForm();
+    operands = {const_cast<clang::Expr *>(decomposed.LHS),
+                const_cast<clang::Expr *>(decomposed.RHS)};
+  } else if (auto *op = llvm::dyn_cast<clang::CXXOperatorCallExpr>(expr)) {
+    operands.assign(op->arg_begin(), op->arg_end());
+    if (!operands.empty() &&
+        llvm::isa_and_nonnull<clang::CXXMethodDecl>(op->getDirectCallee())) {
+      operands[0] = operands[0]->IgnoreParenImpCasts();
+    }
+  } else if (auto *call = llvm::dyn_cast<clang::CXXMemberCallExpr>(expr)) {
+    operands.push_back(getObject(
+        ctx, call->getImplicitObjectArgument()->IgnoreParenImpCasts()));
+    operands.insert(operands.end(), call->arg_begin(), call->arg_end());
+  } else if (auto *call = llvm::dyn_cast<clang::CallExpr>(expr)) {
+    if (const auto *method = llvm::dyn_cast_or_null<clang::CXXMethodDecl>(
+            call->getDirectCallee());
+        method && method->isStatic()) {
+      operands.push_back(new (ctx) clang::OpaqueValueExpr(
+          call->getBeginLoc(), ctx.getCanonicalTagType(method->getParent()),
+          clang::VK_LValue));
+    }
+    operands.insert(operands.end(), call->arg_begin(), call->arg_end());
+  } else if (auto *construct = llvm::dyn_cast<clang::CXXConstructExpr>(expr)) {
+    operands.assign(construct->arg_begin(), construct->arg_end());
+  } else if (auto *member = llvm::dyn_cast<clang::MemberExpr>(expr)) {
+    auto *base = member->getBase()->IgnoreParenImpCasts();
+    if (auto *arrow = llvm::dyn_cast<clang::CXXOperatorCallExpr>(base);
+        arrow && arrow->getOperator() == clang::OO_Arrow) {
+      base = arrow->getArg(0);
+    } else if (auto for_range = GetParentForRange(ctx, member);
+               for_range && !member->isArrow() &&
+               GetClassName(for_range->getRangeInit()->getType()) ==
+                   "std::map") {
+      if (auto type = GetForRangeIteratorType(for_range); !type.isNull()) {
+        base = new (ctx) clang::OpaqueValueExpr(member->getBeginLoc(), type,
+                                                clang::VK_LValue);
+      }
+    }
+    operands.push_back(getObject(ctx, base));
+  }
+  while (!operands.empty() &&
+         llvm::isa<clang::CXXDefaultArgExpr>(operands.back())) {
+    operands.pop_back();
+  }
+  return operands;
+}
+
+class Trial {
+public:
+  explicit Trial(clang::Sema &sema)
+      : diagnostics_(sema.getDiagnostics()),
+        suppressed_(diagnostics_.getSuppressAllDiagnostics()),
+        trap_(sema, /*ForValidityCheck=*/true) {
+    diagnostics_.setSuppressAllDiagnostics(true);
+  }
+  ~Trial() { diagnostics_.setSuppressAllDiagnostics(suppressed_); }
+
+  bool failed() const { return trap_.hasErrorOccurred(); }
+
+private:
+  clang::DiagnosticsEngine &diagnostics_;
+  bool suppressed_;
+  clang::Sema::SFINAETrap trap_;
+};
+
+clang::FunctionDecl *deduce(clang::Sema &sema,
+                            clang::FunctionTemplateDecl *rule,
+                            clang::TemplateArgumentListInfo *explicit_args,
+                            llvm::ArrayRef<clang::Expr *> operands,
+                            clang::SourceLocation loc,
+                            clang::TemplateDeductionResult &result) {
+  clang::FunctionDecl *specialization = nullptr;
+  clang::sema::TemplateDeductionInfo info(loc);
+  auto check = [](llvm::ArrayRef<clang::QualType>, bool) { return false; };
+  result = sema.DeduceTemplateArguments(
+      rule, explicit_args, operands, specialization, info, false, false, false,
+      clang::QualType(), clang::Expr::Classification(), false, check);
+  return result == clang::TemplateDeductionResult::Success ? specialization
+                                                           : nullptr;
+}
+
+clang::FunctionDecl *
+deduceWithLeading(clang::Sema &sema, clang::FunctionTemplateDecl *rule,
+                  llvm::ArrayRef<clang::TemplateArgument> leading,
+                  llvm::ArrayRef<clang::Expr *> operands,
+                  clang::SourceLocation loc) {
+  clang::TemplateArgumentListInfo explicit_args(loc, loc);
+  for (const auto &arg : leading) {
+    if (arg.isNull()) {
+      break;
+    }
+    auto type = arg.getKind() == clang::TemplateArgument::Integral
+                    ? arg.getIntegralType()
+                    : clang::QualType();
+    explicit_args.addArgument(
+        sema.getTrivialTemplateArgumentLoc(arg, type, loc));
+  }
+  if (explicit_args.size() == 0) {
+    return nullptr;
+  }
+  clang::TemplateDeductionResult result;
+  return deduce(sema, rule, &explicit_args, operands, loc, result);
+}
+
+std::vector<clang::TemplateArgument>
+getArgsFromCallee(clang::FunctionTemplateDecl *rule, const Target &want) {
+  std::vector<clang::TemplateArgument> args(
+      rule->getTemplateParameters()->size());
+  const auto *callee = llvm::dyn_cast_or_null<clang::FunctionDecl>(want.decl);
+  const auto *callee_args =
+      callee ? callee->getTemplateSpecializationArgs() : nullptr;
+  const auto *returned = RuleDecls::GetReturned(rule->getTemplatedDecl());
+  const auto *call =
+      llvm::dyn_cast<clang::CallExpr>(RuleDecls::SkipImplicit(returned));
+  const auto *written = call ? llvm::dyn_cast<clang::OverloadExpr>(
+                                   call->getCallee()->IgnoreParenImpCasts())
+                             : nullptr;
+  if (!callee_args || !written || !written->hasExplicitTemplateArgs()) {
+    return args;
+  }
+  unsigned position = 0;
+  for (const auto &arg : written->template_arguments()) {
+    if (position >= callee_args->size()) {
+      break;
+    }
+    int index = -1;
+    const auto &value = arg.getArgument();
+    if (value.getKind() == clang::TemplateArgument::Type) {
+      if (const auto *param =
+              value.getAsType()->getAs<clang::TemplateTypeParmType>()) {
+        index = param->getIndex();
+      }
+    } else if (value.getKind() == clang::TemplateArgument::Expression) {
+      if (const auto *ref = llvm::dyn_cast<clang::DeclRefExpr>(
+              value.getAsExpr()->IgnoreParenImpCasts())) {
+        if (const auto *param = llvm::dyn_cast<clang::NonTypeTemplateParmDecl>(
+                ref->getDecl())) {
+          index = param->getIndex();
+        }
+      }
+    }
+    if (index >= 0 && (unsigned)index < args.size()) {
+      args[index] = callee_args->get(position);
+    }
+    ++position;
+  }
+  return args;
+}
+
+std::vector<clang::TemplateArgument>
+getArgsFromResultType(clang::Sema &sema, clang::FunctionTemplateDecl *rule,
+                      const clang::Expr *use) {
+  auto *params = rule->getTemplateParameters();
+  llvm::SmallVector<clang::DeducedTemplateArgument, 4> deduced(params->size());
+  clang::sema::TemplateDeductionInfo info(use->getBeginLoc());
+  clang::TemplateArgument pattern(rule->getTemplatedDecl()->getReturnType());
+  clang::TemplateArgument actual(use->getType().getCanonicalType());
+  if (sema.DeduceTemplateArguments(params, pattern, actual, info, deduced,
+                                   true) !=
+      clang::TemplateDeductionResult::Success) {
+    return {};
+  }
+  return {deduced.begin(), deduced.end()};
+}
+
+clang::Expr *substituteReturned(clang::Sema &sema,
+                                clang::FunctionTemplateDecl *rule,
+                                clang::FunctionDecl *specialization,
+                                clang::SourceLocation loc) {
+  auto *pattern = rule->getTemplatedDecl();
+  const auto *returned = RuleDecls::GetReturned(pattern);
+  clang::EnterExpressionEvaluationContext unevaluated(
+      sema, clang::Sema::ExpressionEvaluationContext::Unevaluated);
+  clang::Sema::InstantiatingTemplate instantiating(sema, loc, specialization);
+  clang::Sema::ContextRAII context(sema, specialization);
+  clang::LocalInstantiationScope scope(sema);
+  for (unsigned i = 0, j = 0; i < pattern->getNumParams(); ++i) {
+    auto *param = pattern->getParamDecl(i);
+    if (!param->isParameterPack()) {
+      scope.InstantiatedLocal(param, specialization->getParamDecl(j++));
+      continue;
+    }
+    scope.MakeInstantiatedLocalArgPack(param);
+    for (; j < specialization->getNumParams(); ++j) {
+      scope.InstantiatedLocalPackArg(param, specialization->getParamDecl(j));
+    }
+  }
+  auto result =
+      sema.SubstExpr(const_cast<clang::Expr *>(returned),
+                     sema.getTemplateInstantiationArgs(specialization));
+  return result.isInvalid() ? nullptr : result.get();
+}
+
+bool resolvesTo(clang::Sema &sema, clang::FunctionTemplateDecl *rule,
+                clang::FunctionDecl *specialization, const Target &want,
+                clang::SourceLocation loc) {
+  if (!specialization) {
+    return false;
+  }
+  Trial trial(sema);
+  auto *returned = substituteReturned(sema, rule, specialization, loc);
+  return returned && !trial.failed() &&
+         getTarget(sema.Context, returned) == want;
+}
+
+clang::FunctionDecl *matchTemplate(clang::Sema &sema,
+                                   clang::FunctionTemplateDecl *rule,
+                                   const clang::Expr *use, const Target &want,
+                                   llvm::ArrayRef<clang::Expr *> operands) {
+  auto loc = use->getBeginLoc();
+  clang::FunctionDecl *specialization = nullptr;
+  {
+    Trial trial(sema);
+    clang::TemplateDeductionResult result;
+    specialization = deduce(sema, rule, nullptr, operands, loc, result);
+  }
+  if (resolvesTo(sema, rule, specialization, want, loc)) {
+    return specialization;
+  }
+  {
+    Trial trial(sema);
+    specialization = deduceWithLeading(
+        sema, rule, getArgsFromCallee(rule, want), operands, loc);
+  }
+  if (resolvesTo(sema, rule, specialization, want, loc)) {
+    return specialization;
+  }
+  {
+    Trial trial(sema);
+    specialization = deduceWithLeading(
+        sema, rule, getArgsFromResultType(sema, rule, use), operands, loc);
+  }
+  if (resolvesTo(sema, rule, specialization, want, loc)) {
+    return specialization;
+  }
+  return nullptr;
+}
+
+unsigned getGenericNumber(const clang::NamedDecl *param) {
+  auto name = param->getName();
+  unsigned n = 0;
+  if (!name.consume_front("T") || name.getAsInteger(10, n)) {
+    return 0;
+  }
+  return n;
+}
+
+Bindings getBindings(const clang::TemplateParameterList *params,
+                     llvm::ArrayRef<clang::TemplateArgument> args) {
+  Bindings bindings;
+  for (unsigned i = 0; i < params->size() && i < args.size(); ++i) {
+    auto n = getGenericNumber(params->getParam(i));
+    if (!n || args[i].getKind() != clang::TemplateArgument::Type) {
+      continue;
+    }
+    if (bindings.size() < n) {
+      bindings.resize(n);
     }
+    bindings[n - 1] = args[i].getAsType();
+  }
+  return bindings;
+}
+
+struct Candidate {
+  TranslationRule::ExprRule *rule = nullptr;
+  bool native = true;
+  clang::QualType init_type;
+  clang::FunctionTemplateDecl *tmpl = nullptr;
+  clang::FunctionDecl *specialization = nullptr;
+};
+
+bool isBetter(clang::Sema &sema, const Candidate &a, const Candidate &b,
+              clang::SourceLocation loc, unsigned num_operands) {
+  if (a.native != b.native) {
+    return a.native;
+  }
+  if (!a.tmpl || !b.tmpl) {
+    return !a.tmpl && b.tmpl;
+  }
+  Trial trial(sema);
+  if (auto *better = sema.getMoreSpecializedTemplate(
+          a.tmpl, b.tmpl, loc, clang::TPOC_Call, num_operands)) {
+    return better == a.tmpl;
+  }
+  return a.tmpl->getTemplateParameters()->size() <
+         b.tmpl->getTemplateParameters()->size();
+}
+
+ExprMatch findExpr(clang::ASTContext &ctx, const clang::Expr *expr,
+                   clang::QualType *init_type) {
+  auto &sema = RuleDecls::GetSema();
+  const auto *use = expr;
+  auto want = getTarget(ctx, use);
+  if (!want) {
+    return {};
+  }
+  auto operands = getOperands(ctx, use);
+  auto key = RuleDecls::GetExprKey(ctx, use);
+
+  Candidate best;
+  auto consider = [&](const std::string &bucket) {
+    for (auto &[_, entry] : RuleDecls::ExprCandidates(bucket)) {
+      Candidate candidate{entry.rule, entry.native, entry.init_type};
+      auto *function = const_cast<clang::FunctionDecl *>(entry.decl);
+      if (auto *tmpl =
+              function ? function->getDescribedFunctionTemplate() : nullptr) {
+        candidate.tmpl = tmpl;
+        candidate.specialization =
+            matchTemplate(sema, tmpl, use, want, operands);
+        if (!candidate.specialization) {
+          continue;
+        }
+      } else if (getTarget(ctx, entry.returned) != want) {
+        continue;
+      }
+      if (!best.rule || isBetter(sema, candidate, best, use->getBeginLoc(),
+                                 operands.size())) {
+        best = candidate;
+      }
+    }
+  };
+  consider(key);
+  if (!key.empty()) {
+    consider("");
+  }
+
+  log() << "search expr '" << key << "', result:\n";
+  if (!best.rule) {
+    log() << "None\n";
+    return {};
+  }
+  best.rule->dump();
+  if (!best.tmpl) {
+    return {best.rule, {}};
+  }
+  if (init_type && !best.init_type.isNull()) {
+    Trial trial(sema);
+    clang::Sema::InstantiatingTemplate instantiating(sema, use->getBeginLoc(),
+                                                     best.specialization);
+    *init_type = sema.SubstType(
+        best.init_type, sema.getTemplateInstantiationArgs(best.specialization),
+        use->getBeginLoc(), clang::DeclarationName());
+  }
+  return {best.rule,
+          getBindings(
+              best.tmpl->getTemplateParameters(),
+              best.specialization->getTemplateSpecializationArgs()->asArray())};
+}
+
+bool isInstanceOf(clang::Sema &sema, const clang::TypeAliasTemplateDecl *a,
+                  const clang::TypeAliasTemplateDecl *b) {
+  auto *params = b->getTemplateParameters();
+  llvm::SmallVector<clang::DeducedTemplateArgument, 4> deduced(params->size());
+  clang::sema::TemplateDeductionInfo info(a->getLocation());
+  clang::TemplateArgument pattern(b->getTemplatedDecl()->getUnderlyingType());
+  clang::TemplateArgument actual(
+      a->getTemplatedDecl()->getUnderlyingType().getCanonicalType());
+  return sema.DeduceTemplateArguments(params, pattern, actual, info, deduced,
+                                      true) ==
+         clang::TemplateDeductionResult::Success;
+}
+
+TypeMatch findType(clang::ASTContext &ctx, clang::QualType type) {
+  if (auto *rule = RuleRegistry::FindUserType(type)) {
+    return {rule, {}};
+  }
+  if (auto *rule = RuleDecls::FindPlainType(type)) {
+    return {rule, {}};
+  }
+
+  auto &sema = RuleDecls::GetSema();
+  auto canonical = type.getCanonicalType().getUnqualifiedType();
+  TranslationRule::TypeRule *best = nullptr;
+  const clang::TypeAliasTemplateDecl *best_alias = nullptr;
+  Bindings best_bindings;
+  auto consider = [&](const std::string &bucket) {
+    for (auto &[_, entry] : RuleDecls::TypeCandidates(bucket)) {
+      if (const auto *function =
+              llvm::dyn_cast<clang::FunctionTemplateDecl>(entry.decl)) {
+        if (best) {
+          continue;
+        }
+        auto *tmpl = const_cast<clang::FunctionTemplateDecl *>(function);
+        Trial trial(sema);
+        clang::OpaqueValueExpr operand(tmpl->getLocation(),
+                                       ctx.getPointerType(canonical),
+                                       clang::VK_PRValue);
+        clang::TemplateDeductionResult result;
+        if (auto *specialization = deduce(sema, tmpl, nullptr, {&operand},
+                                          tmpl->getLocation(), result)) {
+          best = entry.rule;
+          best_bindings = getBindings(
+              tmpl->getTemplateParameters(),
+              specialization->getTemplateSpecializationArgs()->asArray());
+        }
+        continue;
+      }
+      auto *alias = const_cast<clang::TypeAliasTemplateDecl *>(
+          llvm::cast<clang::TypeAliasTemplateDecl>(entry.decl));
+      Trial trial(sema);
+      clang::sema::TemplateDeductionInfo info(alias->getLocation());
+      if (sema.DeduceTemplateArgumentsFromType(alias, canonical, info) !=
+          clang::TemplateDeductionResult::Success) {
+        continue;
+      }
+      auto *params = alias->getTemplateParameters();
+      llvm::SmallVector<clang::DeducedTemplateArgument, 4> deduced(
+          params->size());
+      clang::TemplateArgument pattern(
+          alias->getTemplatedDecl()->getUnderlyingType());
+      clang::TemplateArgument actual(canonical);
+      if (sema.DeduceTemplateArguments(params, pattern, actual, info, deduced,
+                                       true) !=
+          clang::TemplateDeductionResult::Success) {
+        continue;
+      }
+      if (best_alias && !(isInstanceOf(sema, alias, best_alias) &&
+                          !isInstanceOf(sema, best_alias, alias))) {
+        continue;
+      }
+      best = entry.rule;
+      best_alias = alias;
+      best_bindings = getBindings(params, std::vector<clang::TemplateArgument>(
+                                              deduced.begin(), deduced.end()));
+    }
+  };
+  auto key = RuleDecls::GetTypeKey(canonical);
+  consider(key);
+  if (!key.empty()) {
+    consider("");
+  }
+  return {best, std::move(best_bindings)};
+}
+
+} // namespace
+
+clang::QualType GetInitType(clang::ASTContext &ctx, const clang::Expr *expr) {
+  clang::QualType type;
+  findExpr(ctx, expr, &type);
+  assert(!type.isNull() && "expression must match a rule with an init value");
+  return type;
+}
+
+ExprMatch Find(clang::ASTContext &ctx, const clang::Expr *expr) {
+  return findExpr(ctx, expr, nullptr);
+}
+
+TypeMatch Find(clang::ASTContext &ctx, clang::QualType type) {
+  auto match = findType(ctx, type);
+  log() << "search type " << Printer::ToString(ctx, type)
+        << ", result: " << (match.first ? match.first->type_info.type : "None")
+        << '\n';
+  return match;
+}
+
+bool HasRuleNamed(const clang::FunctionDecl *decl) {
+  return decl->getIdentifier() &&
+         !RuleDecls::ExprCandidates(decl->getName().str()).empty();
+}
+
+std::string MapBinding(clang::ASTContext &ctx, const Bindings &bindings,
+                       unsigned n) {
+  auto type = bindings.at(n);
+  assert(!type.isNull() && "template parameter is not bound to a type");
+  auto mapped = Mapper::Map(ctx, type);
+  if (mapped.empty()) {
+    llvm::errs() << "cpp_type: " << Printer::ToString(ctx, type) << '\n';
+    assert(0 && "Type is not present in the registry");
   }
   return mapped;
 }
 
-// Substitutes concrete types into a target template string using the provided
-// type mapping. Each template parameter in `tgt_template` is replaced with its
-// corresponding instantiated type from `types`.
 //
 // Example:
-//   types        = { {"i32"} }
 //   tgt_template = "Vec<T1>"
 //   result       = "Vec<i32>"
-std::string InstantiateTgt(const Bindings &types,
+std::string InstantiateTgt(clang::ASTContext &ctx, const Bindings &types,
                            const std::string &tgt_template) {
   assert(types.size() <= TranslationRule::kMaxGenerics &&
          "template placeholder exceeds kMaxGenerics");
@@ -40,7 +589,7 @@ std::string InstantiateTgt(const Bindings &types,
       ++pos;
       continue;
     }
-    const auto &repl = types.at(instantiated_template[pos + 1] - '1').value();
+    auto repl = MapBinding(ctx, types, instantiated_template[pos + 1] - '1');
     instantiated_template.replace(pos, 2, repl);
     pos += repl.length();
   }
diff --git a/cpp2rust/converter/rules/matcher.h b/cpp2rust/converter/rules/matcher.h
index f5f9e0db47..35e2e1726a 100644
--- a/cpp2rust/converter/rules/matcher.h
+++ b/cpp2rust/converter/rules/matcher.h
@@ -8,7 +8,6 @@
 #include <clang/AST/Expr.h>
 #include <clang/AST/Type.h>
 
-#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -16,23 +15,22 @@
 #include "converter/translation_rule.h"
 
 namespace cpp2rust::Matcher {
-using Bindings = std::vector<std::optional<std::string>>;
+using Bindings = std::vector<clang::QualType>;
 
 template <typename Rule> using Match = std::pair<Rule *, Bindings>;
 
-std::string Key(const TranslationRule::ExprRule &rule);
-std::string Key(const TranslationRule::TypeRule &rule);
-
 Match<TranslationRule::ExprRule> Find(clang::ASTContext &ctx,
                                       const clang::Expr *expr);
 Match<TranslationRule::TypeRule> Find(clang::ASTContext &ctx,
                                       clang::QualType type);
 
-bool HasRuleNamed(clang::ASTContext &ctx, const clang::FunctionDecl *decl);
+clang::QualType GetInitType(clang::ASTContext &ctx, const clang::Expr *expr);
+
+bool HasRuleNamed(const clang::FunctionDecl *decl);
 
-std::string MapBinding(const Bindings &bindings, unsigned n);
-Bindings MapBindings(const Bindings &bindings);
+std::string MapBinding(clang::ASTContext &ctx, const Bindings &bindings,
+                       unsigned n);
 
-std::string InstantiateTgt(const Bindings &types,
+std::string InstantiateTgt(clang::ASTContext &ctx, const Bindings &types,
                            const std::string &tgt_template);
 } // namespace cpp2rust::Matcher

From b4608ca2d50bfe0cf6f1471669cbdea9518054b2 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 22:06:36 +0100
Subject: [PATCH 14/34] Add ubuntu libc++ config

---
 .github/workflows/run-tests.yml       | 15 ++++++++++++---
 tests/lit/lit/formats/Cpp2RustTest.py | 12 +++++++++++-
 2 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/run-tests.yml b/.github/workflows/run-tests.yml
index 44b5e1d6e2..8e7ad26efc 100644
--- a/.github/workflows/run-tests.yml
+++ b/.github/workflows/run-tests.yml
@@ -15,11 +15,14 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        config:
+          - { name: ubuntu-libstdcxx, os: ubuntu-latest }
+          - { name: ubuntu-libcxx, os: ubuntu-latest, stdlib: libc++ }
+          - { name: macos, os: macos-latest }
         build_type: [Debug, Release]
 
-    runs-on: ${{ matrix.os }}
-    name: Run Tests (${{ matrix.os }}, ${{ matrix.build_type }})
+    runs-on: ${{ matrix.config.os }}
+    name: Run Tests (${{ matrix.config.name }}, ${{ matrix.build_type }})
 
     permissions:
       contents: read
@@ -33,6 +36,12 @@ jobs:
         with:
           llvm-version: 23
 
+      - name: Install libc++
+        if: matrix.config.stdlib == 'libc++'
+        run: |
+          sudo apt-get install -y libc++-23-dev libc++abi-23-dev
+          echo "CPP2RUST_STDLIB=libc++" >> "$GITHUB_ENV"
+
       - name: Configure
         run: |
           mkdir build && cd build
diff --git a/tests/lit/lit/formats/Cpp2RustTest.py b/tests/lit/lit/formats/Cpp2RustTest.py
index 5e77edae55..476d3874ea 100644
--- a/tests/lit/lit/formats/Cpp2RustTest.py
+++ b/tests/lit/lit/formats/Cpp2RustTest.py
@@ -16,6 +16,7 @@
 
 
 MODELS = ("refcount", "unsafe")
+STDLIB = os.environ.get("CPP2RUST_STDLIB")
 PTR_RE = re.compile(r"0x[0-9a-fA-F]+")
 
 RE_XFAIL = re.compile(r"//\s*XFAIL:\s*(.*)")
@@ -109,7 +110,8 @@ def setup(cls, test):
             tmp_dir=tmp_dir,
             rs_file=tmp_dir / "main.rs",
             expectations=TestExpectations.parse(source_text, model),
-            extra_cxxflags=parse_additional_compile_flags(source_text),
+            extra_cxxflags=stdlib_flags(cc_input)
+            + parse_additional_compile_flags(source_text),
             replace_expected=bool(os.environ.get("REPLACE_EXPECTED", False)),
             skip_run=bool(os.environ.get("SKIP_RUN", False)),
         )
@@ -434,12 +436,20 @@ def setup_build_dir(tmp_dir, cc_input):
         str(build_dir),
         "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
     ]
+    if STDLIB:
+        cmd.append(f"-DCMAKE_CXX_FLAGS=-stdlib={STDLIB}")
     _, err, rc = lit.util.executeCommand(cmd)
     if rc != 0:
         return None, "cmake configure failed\n" + err
     return build_dir, None
 
 
+def stdlib_flags(cc_input):
+    if STDLIB and cc_input.suffix == ".cpp":
+        return [f"-stdlib={STDLIB}"]
+    return []
+
+
 def parse_additional_compile_flags(text):
     flags = []
     for m in RE_ADDITIONAL_COMPILE_FLAGS.finditer(text):

From 45c69c13bdacc0096af80fd271efa2b2b2a572ce Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Fri, 2 Oct 2026 22:18:48 +0100
Subject: [PATCH 15/34] Add rule for vector::size_type

---
 cpp2rust/converter/rules/matcher.cpp    | 41 +++++++++++++++++++++++++
 cpp2rust/converter/rules/rule_decls.cpp | 16 ++++++++++
 cpp2rust/converter/rules/rule_decls.h   |  3 ++
 rules/vector/src.cpp                    |  3 ++
 rules/vector/tgt_unsafe.rs              |  4 +++
 5 files changed, 67 insertions(+)

diff --git a/cpp2rust/converter/rules/matcher.cpp b/cpp2rust/converter/rules/matcher.cpp
index 184e878873..7d5899f5b8 100644
--- a/cpp2rust/converter/rules/matcher.cpp
+++ b/cpp2rust/converter/rules/matcher.cpp
@@ -461,10 +461,51 @@ bool isInstanceOf(clang::Sema &sema, const clang::TypeAliasTemplateDecl *a,
          clang::TemplateDeductionResult::Success;
 }
 
+TypeMatch findMemberType(clang::ASTContext &ctx, clang::QualType type) {
+  auto &sema = RuleDecls::GetSema();
+  while (const auto *typedef_type = type->getAs<clang::TypedefType>()) {
+    const auto *decl = typedef_type->getDecl();
+    if (const auto *owner =
+            llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
+                decl->getDeclContext())) {
+      for (auto &[_, entry] :
+           RuleDecls::MemberTypeCandidates(decl->getName().str())) {
+        const auto *alias =
+            llvm::cast<clang::TypeAliasTemplateDecl>(entry.decl);
+        const auto *member = alias->getTemplatedDecl()
+                                 ->getUnderlyingType()
+                                 ->getAs<clang::DependentNameType>();
+        const auto *pattern = member->getQualifier().getAsType();
+        if (!pattern) {
+          continue;
+        }
+        auto *params = alias->getTemplateParameters();
+        llvm::SmallVector<clang::DeducedTemplateArgument, 4> deduced(
+            params->size());
+        clang::sema::TemplateDeductionInfo info(alias->getLocation());
+        Trial trial(sema);
+        if (sema.DeduceTemplateArguments(
+                params, clang::TemplateArgument(clang::QualType(pattern, 0)),
+                clang::TemplateArgument(ctx.getCanonicalTagType(owner)), info,
+                deduced, true) == clang::TemplateDeductionResult::Success) {
+          return {entry.rule,
+                  getBindings(params, std::vector<clang::TemplateArgument>(
+                                          deduced.begin(), deduced.end()))};
+        }
+      }
+    }
+    type = typedef_type->desugar();
+  }
+  return {};
+}
+
 TypeMatch findType(clang::ASTContext &ctx, clang::QualType type) {
   if (auto *rule = RuleRegistry::FindUserType(type)) {
     return {rule, {}};
   }
+  if (auto match = findMemberType(ctx, type); match.first) {
+    return match;
+  }
   if (auto *rule = RuleDecls::FindPlainType(type)) {
     return {rule, {}};
   }
diff --git a/cpp2rust/converter/rules/rule_decls.cpp b/cpp2rust/converter/rules/rule_decls.cpp
index c1cb940708..aa97e90af7 100644
--- a/cpp2rust/converter/rules/rule_decls.cpp
+++ b/cpp2rust/converter/rules/rule_decls.cpp
@@ -28,6 +28,7 @@ constexpr std::string_view kPrefix = "cpp2rust_rules_";
 
 ExprRuleDeclMap exprs_;
 TypeRuleDeclMap types_;
+TypeRuleDeclMap member_types_;
 std::unordered_map<const void *, TranslationRule::TypeRule *> plain_types_;
 std::unordered_map<std::string, TranslationRule::TypeRule *> alias_types_;
 clang::Sema *sema_ = nullptr;
@@ -444,6 +445,14 @@ void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
                           .getAsOpaquePtr());
     return;
   }
+  if (const auto *member =
+          alias->getUnderlyingType()->getAs<clang::DependentNameType>()) {
+    auto key = member->getIdentifier()->getName().str();
+    log() << "rule " << id->module << "::" << id->name << " -> member '" << key
+          << "'\n";
+    member_types_.emplace(std::move(key), TypeRuleDecl{decl, rule});
+    return;
+  }
   auto key = GetTypeKey(alias->getUnderlyingType());
   log() << "rule " << id->module << "::" << id->name << " -> '" << key << "'\n";
   types_.emplace(std::move(key), TypeRuleDecl{decl, rule});
@@ -478,6 +487,7 @@ void Collect(clang::Sema &sema) {
   sema_ = &sema;
   exprs_.clear();
   types_.clear();
+  member_types_.clear();
   plain_types_.clear();
   alias_types_.clear();
   addRules(ctx, ctx.getTranslationUnitDecl());
@@ -512,6 +522,12 @@ ExprCandidates(const std::string &key) {
   return {begin, end};
 }
 
+std::ranges::subrange<TypeRuleDeclMap::iterator>
+MemberTypeCandidates(const std::string &key) {
+  auto [begin, end] = member_types_.equal_range(key);
+  return {begin, end};
+}
+
 std::ranges::subrange<TypeRuleDeclMap::iterator>
 TypeCandidates(const std::string &key) {
   auto [begin, end] = types_.equal_range(key);
diff --git a/cpp2rust/converter/rules/rule_decls.h b/cpp2rust/converter/rules/rule_decls.h
index 617b284b7a..2c1ad0fa18 100644
--- a/cpp2rust/converter/rules/rule_decls.h
+++ b/cpp2rust/converter/rules/rule_decls.h
@@ -52,4 +52,7 @@ ExprCandidates(const std::string &key);
 
 std::ranges::subrange<TypeRuleDeclMap::iterator>
 TypeCandidates(const std::string &key);
+
+std::ranges::subrange<TypeRuleDeclMap::iterator>
+MemberTypeCandidates(const std::string &key);
 } // namespace cpp2rust::RuleDecls
diff --git a/rules/vector/src.cpp b/rules/vector/src.cpp
index 5439b60cc1..e530287dec 100644
--- a/rules/vector/src.cpp
+++ b/rules/vector/src.cpp
@@ -26,6 +26,9 @@ void t4(It *);
 template <typename T1, typename T2 = std::allocator<T1>>
 using t5 = std::vector<T1, T2>;
 
+template <typename T1, typename T2>
+using t8 = typename std::vector<T1, T2>::size_type;
+
 #if defined(__linux__)
 template <template <typename...> class Iterator, typename Pointer, typename T1,
           typename T2,
diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs
index efa218c54f..d0707971d1 100644
--- a/rules/vector/tgt_unsafe.rs
+++ b/rules/vector/tgt_unsafe.rs
@@ -33,6 +33,10 @@ fn t7<T1>() -> *const T1 {
     Default::default()
 }
 
+fn t8() -> usize {
+    0_usize
+}
+
 unsafe fn f1<T1>(a0: &mut Vec<T1>, a1: *const T1) -> *const T1 {
     let pos = a1.offset_from(a0.as_ptr()) as usize;
     a0.remove(pos);

From 5b34f11a0bd5a83430a20a18f9fd12b9b03d052d Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 12:24:23 +0100
Subject: [PATCH 16/34] Update rules

---
 rules/iomanip/src.cpp            | 4 +---
 rules/pair/src.cpp               | 9 +++++----
 rules/unique_ptr/src.cpp         | 4 ++++
 rules/unique_ptr/tgt_refcount.rs | 4 ++++
 rules/unique_ptr/tgt_unsafe.rs   | 4 ++++
 5 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/rules/iomanip/src.cpp b/rules/iomanip/src.cpp
index 2a1a628ecf..0b6049574b 100644
--- a/rules/iomanip/src.cpp
+++ b/rules/iomanip/src.cpp
@@ -3,6 +3,4 @@
 
 #include <iomanip>
 
-#if __cplusplus >= 201402L
-auto f1(int n) { return std::setw(n); }
-#endif
+decltype(std::setw(0)) f1(int n) { return std::setw(n); }
diff --git a/rules/pair/src.cpp b/rules/pair/src.cpp
index c72845700c..635a130f51 100644
--- a/rules/pair/src.cpp
+++ b/rules/pair/src.cpp
@@ -34,15 +34,16 @@ std::pair<T1, T2> f7(T3 &&a0, T4 &&a1) {
   return std::pair<T1, T2>(std::forward<T3>(a0), std::forward<T4>(a1));
 }
 
-#if __cplusplus >= 201402L
-template <class T1, class T2> auto f9(T1 &&a0, T2 &a1) {
+template <class T1, class T2>
+auto f9(T1 &&a0, T2 &a1) -> decltype(std::make_pair(std::move(a0), a1)) {
   return std::make_pair(std::move(a0), a1);
 }
 
-template <class T1, class T2> auto f10(T1 &&a0, T2 &&a1) {
+template <class T1, class T2>
+auto f10(T1 &&a0, T2 &&a1)
+    -> decltype(std::make_pair(std::move(a0), std::move(a1))) {
   return std::make_pair(std::move(a0), std::move(a1));
 }
-#endif
 
 template <typename T1, typename T2> T1 &f11(std::pair<T1, T2> &a0) {
   return a0.first;
diff --git a/rules/unique_ptr/src.cpp b/rules/unique_ptr/src.cpp
index c25e56274f..042851c347 100644
--- a/rules/unique_ptr/src.cpp
+++ b/rules/unique_ptr/src.cpp
@@ -46,6 +46,10 @@ template <typename T1> void f9(std::unique_ptr<T1[]> &o) {
   return o.reset(nullptr);
 }
 
+template <typename T1> void f16(std::unique_ptr<T1> &o) {
+  return o.reset(nullptr);
+}
+
 template <typename T1> std::unique_ptr<T1> f10() {
   return std::unique_ptr<T1>();
 }
diff --git a/rules/unique_ptr/tgt_refcount.rs b/rules/unique_ptr/tgt_refcount.rs
index 46600c01d3..d062ab77d6 100644
--- a/rules/unique_ptr/tgt_refcount.rs
+++ b/rules/unique_ptr/tgt_refcount.rs
@@ -75,3 +75,7 @@ fn f14<T1: ByteRepr>(a0: Ptr<Option<Value<T1>>>, a1: &mut Option<Value<T1>>) {
 fn f15<T1: ByteRepr>(a0: Ptr<Option<Value<Box<[T1]>>>>, a1: &mut Option<Value<Box<[T1]>>>) {
     a0.write(a1.take())
 }
+
+fn f16<T1: ByteRepr>(a0: Ptr<Option<Value<T1>>>) {
+    a0.write(None)
+}
diff --git a/rules/unique_ptr/tgt_unsafe.rs b/rules/unique_ptr/tgt_unsafe.rs
index 72602f1634..c902a5182f 100644
--- a/rules/unique_ptr/tgt_unsafe.rs
+++ b/rules/unique_ptr/tgt_unsafe.rs
@@ -69,3 +69,7 @@ unsafe fn f14<T1>(a0: &mut Option<Box<T1>>, a1: &mut Option<Box<T1>>) {
 unsafe fn f15<T1>(a0: &mut Option<Box<[T1]>>, a1: &mut Option<Box<[T1]>>) {
     *a0 = a1.take()
 }
+
+unsafe fn f16<T1>(a0: &mut Option<Box<T1>>) {
+    *a0 = None
+}

From 93a3acfe84fe0e5698f2469fb57f6e775edfef1a Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 12:24:53 +0100
Subject: [PATCH 17/34] Add IsStdSetw

---
 cpp2rust/converter/converter.cpp     |  2 +-
 cpp2rust/converter/converter_lib.cpp | 12 ++++++++++++
 cpp2rust/converter/converter_lib.h   |  2 ++
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index fb99ae9a53..0dfbe55bc6 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -1657,7 +1657,7 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
     fmt_trait = "x";
   } else if (arg_str.contains("std::dec")) {
     fmt_trait = "";
-  } else if (arg_str.contains("Setw")) {
+  } else if (IsStdSetw(arg)) {
     fmt_width = Trim(ToString(arg));
   } else if (!arg->getType()->isCharType() &&
              Mapper::Map(ctx_, arg->getType()) !=
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index e16f3d0421..f0487eef54 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -1458,6 +1458,18 @@ clang::Expr *GetCallee(clang::CallExpr *expr) {
   return expr->getCallee();
 }
 
+bool IsStdSetw(const clang::Expr *expr) {
+  expr = expr->IgnoreImplicit();
+  if (const auto *construct = llvm::dyn_cast<clang::CXXConstructExpr>(expr);
+      construct && construct->isElidable()) {
+    expr = construct->getArg(0)->IgnoreImplicit();
+  }
+  const auto *call = llvm::dyn_cast<clang::CallExpr>(expr);
+  const auto *callee = call ? call->getDirectCallee() : nullptr;
+  return callee && callee->isInStdNamespace() && callee->getIdentifier() &&
+         callee->getName() == "setw";
+}
+
 bool HasReceiver(clang::Expr *expr) {
   if (clang::isa<clang::CXXMemberCallExpr>(expr))
     return true;
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index 7d36b9201e..460b4dcdec 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -255,6 +255,8 @@ bool MayCauseBorrowMutError(const clang::Expr *lhs, const clang::Expr *rhs);
 
 bool ArgsMayAlias(const clang::Expr *a, const clang::Expr *b);
 
+bool IsStdSetw(const clang::Expr *expr);
+
 bool HasReceiver(clang::Expr *expr);
 
 std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,

From fc845f2312e92e561a3fb2c51ff2972e182581b6 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 12:29:44 +0100
Subject: [PATCH 18/34] Register user types on every TU

---
 cpp2rust/converter/converter.cpp        | 37 ++++++++++++++++++++-----
 cpp2rust/converter/converter.h          |  2 ++
 cpp2rust/converter/rules/registry.cpp   |  3 +-
 cpp2rust/converter/rules/rule_decls.cpp | 11 +++++++-
 4 files changed, 43 insertions(+), 10 deletions(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 0dfbe55bc6..0099e4db4f 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -23,6 +23,7 @@
 #include "converter/lex.h"
 #include "converter/mapper.h"
 #include "converter/printer.h"
+#include "converter/rules/matcher.h"
 #include "converter/rules/registry.h"
 
 namespace cpp2rust {
@@ -332,15 +333,35 @@ bool Converter::VisitUsingType(clang::UsingType *type) {
 
 bool Converter::Convert(clang::Decl *decl) { return TraverseDecl(decl); }
 
+void Converter::RegisterUserTypes(clang::Decl *decl) {
+  if (auto *ns = llvm::dyn_cast<clang::NamespaceDecl>(decl)) {
+    for (auto *child : ns->decls()) {
+      RegisterUserTypes(child);
+    }
+  } else if (auto *tmpl = llvm::dyn_cast<clang::ClassTemplateDecl>(decl)) {
+    for (auto *specialization : tmpl->specializations()) {
+      RegisterUserTypes(specialization);
+    }
+  } else if (auto *tag = llvm::dyn_cast<clang::TagDecl>(decl)) {
+    if (!Mapper::Contains(ctx_, ctx_.getCanonicalTagType(tag))) {
+      RuleRegistry::AddRuleForUserDefinedType(ctx_, tag);
+    }
+  }
+}
+
 bool Converter::VisitTranslationUnitDecl(clang::TranslationUnitDecl *decl) {
   for (auto *child : decl->decls()) {
-    if (IsUserDefinedDecl(child) &&
-        (IsInMainFile(child) || !decl_ids_.contains(GetID(child)))) {
-      Convert(child);
-      if (!hoisted_records_.empty()) {
-        StrCat(hoisted_records_);
-        hoisted_records_.clear();
-      }
+    if (!IsUserDefinedDecl(child)) {
+      continue;
+    }
+    if (!IsInMainFile(child) && decl_ids_.contains(GetID(child))) {
+      RegisterUserTypes(child);
+      continue;
+    }
+    Convert(child);
+    if (!hoisted_records_.empty()) {
+      StrCat(hoisted_records_);
+      hoisted_records_.clear();
     }
   }
   return false;
@@ -1230,6 +1251,8 @@ bool Converter::VisitNamespaceDecl(clang::NamespaceDecl *decl) {
   for (auto *child : decl->decls()) {
     if (IsInMainFile(child) || !decl_ids_.contains(GetID(child))) {
       Convert(child);
+    } else {
+      RegisterUserTypes(child);
     }
   }
   return false;
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 439eb7ace5..ef21fbc291 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -178,6 +178,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitNamespaceDecl(clang::NamespaceDecl *decl);
 
+  void RegisterUserTypes(clang::Decl *decl);
+
   virtual bool VisitTypedefDecl(clang::TypedefDecl *decl);
   virtual bool VisitTypeAliasDecl(clang::TypeAliasDecl *decl);
   virtual bool VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl *decl);
diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp
index 2484228296..cf9654b675 100644
--- a/cpp2rust/converter/rules/registry.cpp
+++ b/cpp2rust/converter/rules/registry.cpp
@@ -26,8 +26,7 @@ std::unordered_map<std::string, TranslationRule::TypeRule> types_;
 std::unordered_map<const void *, TranslationRule::TypeRule> user_types_;
 
 void AddTypeRule(clang::QualType type, TranslationRule::TypeRule &&rule) {
-  user_types_.try_emplace(type.getCanonicalType().getAsOpaquePtr(),
-                          std::move(rule));
+  user_types_.try_emplace(type.getAsOpaquePtr(), std::move(rule));
 }
 
 void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
diff --git a/cpp2rust/converter/rules/rule_decls.cpp b/cpp2rust/converter/rules/rule_decls.cpp
index aa97e90af7..944e325d31 100644
--- a/cpp2rust/converter/rules/rule_decls.cpp
+++ b/cpp2rust/converter/rules/rule_decls.cpp
@@ -91,7 +91,16 @@ const clang::Expr *GetReturned(const clang::FunctionDecl *decl) {
     return nullptr;
   }
   const auto *ret = llvm::dyn_cast<clang::ReturnStmt>(*body->body_begin());
-  return ret ? ret->getRetValue() : nullptr;
+  const clang::Expr *returned = ret ? ret->getRetValue() : nullptr;
+  while (returned) {
+    const auto *construct =
+        llvm::dyn_cast<clang::CXXConstructExpr>(SkipImplicit(returned));
+    if (!construct || !construct->isElidable()) {
+      break;
+    }
+    returned = construct->getArg(0);
+  }
+  return returned;
 }
 
 namespace {

From 8efcc17b5d300e2903bf1d7644bbd675be61a5b6 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 12:42:09 +0100
Subject: [PATCH 19/34] Fix addition of user types

---
 cpp2rust/converter/converter.cpp              |  48 +++-----
 cpp2rust/converter/converter.h                |   6 +-
 cpp2rust/converter/converter_lib.cpp          |  12 --
 cpp2rust/converter/converter_lib.h            |   3 -
 .../converter/models/converter_refcount.cpp   |   3 -
 cpp2rust/converter/rules/matcher.cpp          |  20 +++-
 cpp2rust/converter/rules/matcher.h            |   3 +
 cpp2rust/converter/rules/registry.cpp         | 109 +++++++-----------
 cpp2rust/converter/rules/registry.h           |   8 +-
 .../out/unsafe/lambda_capture_copy_ctor.rs    |   3 +-
 10 files changed, 81 insertions(+), 134 deletions(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 0099e4db4f..12becfca28 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -182,7 +182,6 @@ bool Converter::VisitRecordType(clang::RecordType *type) {
   }
 
   StrCat(GetRecordName(decl));
-  RuleRegistry::AddRuleForUserDefinedType(ctx_, decl);
   return false;
 }
 
@@ -333,29 +332,12 @@ bool Converter::VisitUsingType(clang::UsingType *type) {
 
 bool Converter::Convert(clang::Decl *decl) { return TraverseDecl(decl); }
 
-void Converter::RegisterUserTypes(clang::Decl *decl) {
-  if (auto *ns = llvm::dyn_cast<clang::NamespaceDecl>(decl)) {
-    for (auto *child : ns->decls()) {
-      RegisterUserTypes(child);
-    }
-  } else if (auto *tmpl = llvm::dyn_cast<clang::ClassTemplateDecl>(decl)) {
-    for (auto *specialization : tmpl->specializations()) {
-      RegisterUserTypes(specialization);
-    }
-  } else if (auto *tag = llvm::dyn_cast<clang::TagDecl>(decl)) {
-    if (!Mapper::Contains(ctx_, ctx_.getCanonicalTagType(tag))) {
-      RuleRegistry::AddRuleForUserDefinedType(ctx_, tag);
-    }
-  }
-}
-
 bool Converter::VisitTranslationUnitDecl(clang::TranslationUnitDecl *decl) {
   for (auto *child : decl->decls()) {
     if (!IsUserDefinedDecl(child)) {
       continue;
     }
     if (!IsInMainFile(child) && decl_ids_.contains(GetID(child))) {
-      RegisterUserTypes(child);
       continue;
     }
     Convert(child);
@@ -708,11 +690,18 @@ bool Converter::IsPassThroughRule(clang::Expr *expr) const {
              rule->body[0]);
 }
 
-bool Converter::RecordDerivesCopy(const clang::RecordDecl *decl) const {
-  auto *derives =
-      RuleRegistry::MappedDerives(ctx_, ctx_.getCanonicalTagType(decl));
-  return derives &&
-         std::find(derives->begin(), derives->end(), "Copy") != derives->end();
+bool Converter::RecordDerivesCopy(const clang::RecordDecl *decl) {
+  if (auto *rule = Matcher::FindLoaded(ctx_, ctx_.getCanonicalTagType(decl))) {
+    auto &derives = rule->type_info.derives;
+    return std::find(derives.begin(), derives.end(), "Copy") != derives.end();
+  }
+  decl = decl->getDefinition();
+  if (!decl) {
+    return false;
+  }
+  auto attrs = GetStructAttributes(decl);
+  return std::find(attrs.begin(), attrs.end(), std::string_view("Copy")) !=
+         attrs.end();
 }
 
 bool Converter::RecordHasCopyableFields(const clang::RecordDecl *decl) {
@@ -771,7 +760,6 @@ bool Converter::VisitRecordDecl(clang::RecordDecl *decl) {
     return false;
   }
 
-  RuleRegistry::AddRuleForUserDefinedType(ctx_, decl);
   EmitRustStructOrUnion(decl);
 
   return false;
@@ -838,9 +826,6 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
     EmitReprC(decl);
   }
   auto attrs = GetStructAttributes(decl);
-  RuleRegistry::SetDerives(
-      ctx_, ctx_.getCanonicalTagType(decl),
-      std::vector<std::string>(attrs.begin(), attrs.end()));
   StrCat("#[derive(");
   for (auto *attr : attrs) {
     StrCat(attr, ',');
@@ -938,9 +923,6 @@ void Converter::EmitReprC(clang::RecordDecl *decl) {
 void Converter::EmitRustUnion(clang::RecordDecl *decl) {
   EmitReprC(decl);
   auto attrs = GetStructAttributes(decl);
-  RuleRegistry::SetDerives(
-      ctx_, ctx_.getCanonicalTagType(decl),
-      std::vector<std::string>(attrs.begin(), attrs.end()));
   StrCat("#[derive(");
   for (auto *attr : attrs) {
     StrCat(attr, ',');
@@ -964,7 +946,6 @@ void Converter::EmitRustUnion(clang::RecordDecl *decl) {
 bool Converter::VisitCXXRecordDecl(clang::CXXRecordDecl *decl) {
   decl->dump(log());
 
-  RuleRegistry::AddRuleForUserDefinedType(ctx_, decl);
   if (!IsConvertibleCXXRecordDecl(decl)) {
     return false;
   }
@@ -1251,8 +1232,6 @@ bool Converter::VisitNamespaceDecl(clang::NamespaceDecl *decl) {
   for (auto *child : decl->decls()) {
     if (IsInMainFile(child) || !decl_ids_.contains(GetID(child))) {
       Convert(child);
-    } else {
-      RegisterUserTypes(child);
     }
   }
   return false;
@@ -3806,10 +3785,9 @@ bool Converter::VisitOffsetOfExpr(clang::OffsetOfExpr *expr) {
 
 bool Converter::VisitEnumDecl(clang::EnumDecl *decl) {
   ENSURE(decl_ids_.insert(GetID(decl)).second);
-  if (Mapper::Contains(ctx_, ctx_.getCanonicalTagType(decl))) {
+  if (Matcher::FindLoaded(ctx_, ctx_.getCanonicalTagType(decl))) {
     return false;
   }
-  RuleRegistry::AddRuleForUserDefinedType(ctx_, decl);
   auto name = GetRecordName(decl);
   StrCat(std::format("pub type {} = {};", name,
                      GetUnsafeTypeAsString(decl->getIntegerType())));
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index ef21fbc291..e2591f2ff1 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -178,8 +178,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitNamespaceDecl(clang::NamespaceDecl *decl);
 
-  void RegisterUserTypes(clang::Decl *decl);
-
   virtual bool VisitTypedefDecl(clang::TypedefDecl *decl);
   virtual bool VisitTypeAliasDecl(clang::TypeAliasDecl *decl);
   virtual bool VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl *decl);
@@ -347,7 +345,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   // Option<fn> implements Copy
   virtual bool FunctionPointerImplementsCopy() const { return true; }
 
-  bool TypeIsCopyable(clang::QualType ty) const {
+  bool TypeIsCopyable(clang::QualType ty) {
     if (ty->isFunctionPointerType() || ty->isFunctionType()) {
       return FunctionPointerImplementsCopy();
     }
@@ -738,7 +736,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool TypeDerivesDefault(clang::QualType qual_type);
 
-  bool RecordDerivesCopy(const clang::RecordDecl *decl) const;
+  bool RecordDerivesCopy(const clang::RecordDecl *decl);
 
   bool IsPassThroughRule(clang::Expr *expr) const;
 
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index f0487eef54..90e8d28d8a 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -1248,18 +1248,6 @@ clang::CXXConstructExpr *MakeConstructExpr(clang::ASTContext &ctx,
       clang::SourceRange());
 }
 
-std::vector<clang::CXXRecordDecl *>
-GetNestedStructs(const clang::CXXRecordDecl *decl) {
-  std::vector<clang::CXXRecordDecl *> nested_record_decls;
-  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;
-}
-
 std::optional<clang::ArrayRef<clang::TemplateArgument>>
 GetTemplateArgs(clang::QualType qual_type, clang::Expr *expr) {
   if (auto ty = clang::dyn_cast<clang::TemplateSpecializationType>(qual_type)) {
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index 460b4dcdec..fa4986f81d 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -217,9 +217,6 @@ clang::CXXConstructExpr *MakeConstructExpr(clang::ASTContext &ctx,
                                            clang::CXXConstructorDecl *ctor,
                                            llvm::ArrayRef<clang::Expr *> args);
 
-std::vector<clang::CXXRecordDecl *>
-GetNestedStructs(const clang::CXXRecordDecl *decl);
-
 std::optional<clang::ArrayRef<clang::TemplateArgument>>
 GetTemplateArgs(clang::QualType qual_type, clang::Expr *expr = nullptr);
 
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index ab3165c413..040d4ce605 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -631,9 +631,6 @@ void ConverterRefCount::EmitRustUnion(clang::RecordDecl *decl) {
   auto name = GetRecordName(decl);
 
   auto attrs = GetStructAttributes(decl);
-  RuleRegistry::SetDerives(
-      ctx_, ctx_.getCanonicalTagType(decl),
-      std::vector<std::string>(attrs.begin(), attrs.end()));
 
   auto size = ctx_.getTypeSizeInChars(ctx_.getCanonicalTagType(decl));
   StrCat(std::format(
diff --git a/cpp2rust/converter/rules/matcher.cpp b/cpp2rust/converter/rules/matcher.cpp
index 7d5899f5b8..3458762e7c 100644
--- a/cpp2rust/converter/rules/matcher.cpp
+++ b/cpp2rust/converter/rules/matcher.cpp
@@ -499,10 +499,7 @@ TypeMatch findMemberType(clang::ASTContext &ctx, clang::QualType type) {
   return {};
 }
 
-TypeMatch findType(clang::ASTContext &ctx, clang::QualType type) {
-  if (auto *rule = RuleRegistry::FindUserType(type)) {
-    return {rule, {}};
-  }
+TypeMatch findLoadedType(clang::ASTContext &ctx, clang::QualType type) {
   if (auto match = findMemberType(ctx, type); match.first) {
     return match;
   }
@@ -574,6 +571,16 @@ TypeMatch findType(clang::ASTContext &ctx, clang::QualType type) {
   return {best, std::move(best_bindings)};
 }
 
+TypeMatch findType(clang::ASTContext &ctx, clang::QualType type) {
+  auto match = findLoadedType(ctx, type);
+  if (!match.first) {
+    if (auto *rule = RuleRegistry::FindUserType(ctx, type)) {
+      return {rule, {}};
+    }
+  }
+  return match;
+}
+
 } // namespace
 
 clang::QualType GetInitType(clang::ASTContext &ctx, const clang::Expr *expr) {
@@ -587,6 +594,11 @@ ExprMatch Find(clang::ASTContext &ctx, const clang::Expr *expr) {
   return findExpr(ctx, expr, nullptr);
 }
 
+TranslationRule::TypeRule *FindLoaded(clang::ASTContext &ctx,
+                                      clang::QualType type) {
+  return findLoadedType(ctx, type).first;
+}
+
 TypeMatch Find(clang::ASTContext &ctx, clang::QualType type) {
   auto match = findType(ctx, type);
   log() << "search type " << Printer::ToString(ctx, type)
diff --git a/cpp2rust/converter/rules/matcher.h b/cpp2rust/converter/rules/matcher.h
index 35e2e1726a..f471bbfe96 100644
--- a/cpp2rust/converter/rules/matcher.h
+++ b/cpp2rust/converter/rules/matcher.h
@@ -21,6 +21,9 @@ template <typename Rule> using Match = std::pair<Rule *, Bindings>;
 
 Match<TranslationRule::ExprRule> Find(clang::ASTContext &ctx,
                                       const clang::Expr *expr);
+TranslationRule::TypeRule *FindLoaded(clang::ASTContext &ctx,
+                                      clang::QualType type);
+
 Match<TranslationRule::TypeRule> Find(clang::ASTContext &ctx,
                                       clang::QualType type);
 
diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp
index cf9654b675..57c653cd15 100644
--- a/cpp2rust/converter/rules/registry.cpp
+++ b/cpp2rust/converter/rules/registry.cpp
@@ -25,8 +25,17 @@ std::unordered_map<std::string, TranslationRule::TypeRule> types_;
 
 std::unordered_map<const void *, TranslationRule::TypeRule> user_types_;
 
-void AddTypeRule(clang::QualType type, TranslationRule::TypeRule &&rule) {
-  user_types_.try_emplace(type.getAsOpaquePtr(), std::move(rule));
+TranslationRule::TypeRule userPointerRule(const std::string &rs_name,
+                                          bool abstract) {
+  switch (model_) {
+  case Model::kUnsafe:
+    return TranslationRule::TypeRule::UnsafePtr(
+        (abstract ? "*mut dyn " : "*mut ") + rs_name);
+  case Model::kRefCount:
+    return TranslationRule::TypeRule::RefcountPtr(
+        (abstract ? "PtrDyn<dyn " : "Ptr<") + rs_name + '>');
+  }
+  __builtin_unreachable();
 }
 
 void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
@@ -71,10 +80,39 @@ TranslationRule::TypeRule *FindTypeRule(const std::string &module,
   return it == types_.end() ? nullptr : &it->second;
 }
 
-TranslationRule::TypeRule *FindUserType(clang::QualType type) {
-  auto it = user_types_.find(
-      type.getCanonicalType().getUnqualifiedType().getAsOpaquePtr());
-  return it == user_types_.end() ? nullptr : &it->second;
+TranslationRule::TypeRule *FindUserType(clang::ASTContext &ctx,
+                                        clang::QualType type) {
+  type = type.getCanonicalType().getUnqualifiedType();
+  auto it = user_types_.find(type.getAsOpaquePtr());
+  if (it != user_types_.end()) {
+    return &it->second;
+  }
+  bool pointer = type->isPointerType();
+  auto tag_type = pointer ? type->getPointeeType() : type;
+  if (tag_type.hasQualifiers()) {
+    return nullptr;
+  }
+  auto *tag = tag_type->getAsTagDecl();
+  if (!tag || !IsUserDefinedDecl(tag)) {
+    return nullptr;
+  }
+  auto rs_name =
+      Printer::ToRustName(Printer::ToString(ctx, GetTypeForDecl(ctx, tag)));
+  if (!pointer) {
+    return &user_types_
+                .emplace(type.getAsOpaquePtr(),
+                         TranslationRule::TypeRule::Plain(rs_name))
+                .first->second;
+  }
+  auto *cxx = llvm::dyn_cast<clang::CXXRecordDecl>(tag);
+  auto *definition = cxx ? cxx->getDefinition() : nullptr;
+  if (!definition) {
+    return nullptr;
+  }
+  return &user_types_
+              .emplace(type.getAsOpaquePtr(),
+                       userPointerRule(rs_name, definition->isAbstract()))
+              .first->second;
 }
 
 void ResetUserTypes() { user_types_.clear(); }
@@ -107,19 +145,6 @@ bool MapsToRefcountPointer(clang::ASTContext &ctx, clang::QualType qual_type) {
   return rule && rule->type_info.is_refcount_pointer;
 }
 
-const std::vector<std::string> *MappedDerives(clang::ASTContext &ctx,
-                                              clang::QualType qual_type) {
-  auto rule = Search(ctx, qual_type).first;
-  return rule ? &rule->type_info.derives : nullptr;
-}
-
-void SetDerives(clang::ASTContext &ctx, clang::QualType qual_type,
-                std::vector<std::string> derives) {
-  if (auto *rule = Search(ctx, qual_type).first) {
-    rule->type_info.derives = std::move(derives);
-  }
-}
-
 bool ReturnsPointer(clang::ASTContext &ctx, const clang::Expr *expr) {
   auto rule = Search(ctx, expr).first;
   return rule && rule->return_type.is_pointer();
@@ -148,52 +173,6 @@ bool IsLibcPassthrough(clang::ASTContext &ctx, const clang::Expr *expr) {
 
 Model CurrentModel() { return model_; }
 
-void AddRuleForUserDefinedType(clang::ASTContext &ctx, clang::NamedDecl *decl) {
-  auto type = ctx.getCanonicalTagType(llvm::cast<clang::TagDecl>(decl));
-  auto ptr = ctx.getPointerType(type);
-  auto rs_name =
-      Printer::ToRustName(Printer::ToString(ctx, GetTypeForDecl(ctx, decl)));
-
-  AddTypeRule(type, TranslationRule::TypeRule::Plain(rs_name));
-
-  if (auto record_decl = llvm::dyn_cast<clang::RecordDecl>(decl)) {
-    // Forward declaration
-    if (!record_decl->isThisDeclarationADefinition()) {
-      return;
-    }
-
-    if (auto cxx_decl = llvm::dyn_cast<clang::CXXRecordDecl>(record_decl)) {
-      if (cxx_decl->isAbstract()) {
-        switch (model_) {
-        case Model::kUnsafe:
-          AddTypeRule(
-              ptr, TranslationRule::TypeRule::UnsafePtr("*mut dyn " + rs_name));
-          break;
-        case Model::kRefCount:
-          AddTypeRule(ptr, TranslationRule::TypeRule::RefcountPtr(
-                               "PtrDyn<dyn " + rs_name + '>'));
-          break;
-        }
-      } else {
-        switch (model_) {
-        case Model::kUnsafe:
-          AddTypeRule(ptr,
-                      TranslationRule::TypeRule::UnsafePtr("*mut " + rs_name));
-          break;
-        case Model::kRefCount:
-          AddTypeRule(ptr, TranslationRule::TypeRule::RefcountPtr(
-                               "Ptr<" + rs_name + '>'));
-          break;
-        }
-      }
-
-      for (auto *nested : GetNestedStructs(cxx_decl)) {
-        AddRuleForUserDefinedType(ctx, nested);
-      }
-    }
-  }
-}
-
 void Load(Model model, const std::string &rules_dir) {
   model_ = model;
 
diff --git a/cpp2rust/converter/rules/registry.h b/cpp2rust/converter/rules/registry.h
index e5b53feb67..2134252e3b 100644
--- a/cpp2rust/converter/rules/registry.h
+++ b/cpp2rust/converter/rules/registry.h
@@ -24,7 +24,8 @@ TranslationRule::ExprRule *FindExprRule(const std::string &module,
 TranslationRule::TypeRule *FindTypeRule(const std::string &module,
                                         const std::string &name);
 
-TranslationRule::TypeRule *FindUserType(clang::QualType type);
+TranslationRule::TypeRule *FindUserType(clang::ASTContext &ctx,
+                                        clang::QualType type);
 
 void ResetUserTypes();
 
@@ -41,13 +42,8 @@ bool ParamIsPointer(clang::ASTContext &ctx, const clang::Expr *expr,
                     unsigned index);
 bool MapsToPointer(clang::ASTContext &ctx, clang::QualType qual_type);
 bool MapsToRefcountPointer(clang::ASTContext &ctx, clang::QualType qual_type);
-const std::vector<std::string> *MappedDerives(clang::ASTContext &ctx,
-                                              clang::QualType qual_type);
-void SetDerives(clang::ASTContext &ctx, clang::QualType qual_type,
-                std::vector<std::string> derives);
 
 Model CurrentModel();
 
 void Load(Model model, const std::string &rules_dir);
-void AddRuleForUserDefinedType(clang::ASTContext &ctx, clang::NamedDecl *decl);
 } // namespace cpp2rust::RuleRegistry
diff --git a/tests/unit/out/unsafe/lambda_capture_copy_ctor.rs b/tests/unit/out/unsafe/lambda_capture_copy_ctor.rs
index 942d060047..c4575b7108 100644
--- a/tests/unit/out/unsafe/lambda_capture_copy_ctor.rs
+++ b/tests/unit/out/unsafe/lambda_capture_copy_ctor.rs
@@ -124,8 +124,7 @@ unsafe fn main_0() -> i32 {
     );
     let mut a2: _ = (|| {
         return ((arr[(0) as usize].copies) + (arr[(1) as usize].copies));
-    })
-    .clone();
+    });
     assert!(((unsafe { a2() }) == (4)));
     {
         let mut m2: _ = (|| {});

From 153bb220a3cb10189ac345f184791ac41eeb3cc5 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 14:13:38 +0100
Subject: [PATCH 20/34] Revert "Add ubuntu libc++ config"

This reverts commit b4608ca2d50bfe0cf6f1471669cbdea9518054b2.
---
 .github/workflows/run-tests.yml       | 15 +++------------
 tests/lit/lit/formats/Cpp2RustTest.py | 12 +-----------
 2 files changed, 4 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/run-tests.yml b/.github/workflows/run-tests.yml
index 8e7ad26efc..44b5e1d6e2 100644
--- a/.github/workflows/run-tests.yml
+++ b/.github/workflows/run-tests.yml
@@ -15,14 +15,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        config:
-          - { name: ubuntu-libstdcxx, os: ubuntu-latest }
-          - { name: ubuntu-libcxx, os: ubuntu-latest, stdlib: libc++ }
-          - { name: macos, os: macos-latest }
+        os: [ubuntu-latest, macos-latest]
         build_type: [Debug, Release]
 
-    runs-on: ${{ matrix.config.os }}
-    name: Run Tests (${{ matrix.config.name }}, ${{ matrix.build_type }})
+    runs-on: ${{ matrix.os }}
+    name: Run Tests (${{ matrix.os }}, ${{ matrix.build_type }})
 
     permissions:
       contents: read
@@ -36,12 +33,6 @@ jobs:
         with:
           llvm-version: 23
 
-      - name: Install libc++
-        if: matrix.config.stdlib == 'libc++'
-        run: |
-          sudo apt-get install -y libc++-23-dev libc++abi-23-dev
-          echo "CPP2RUST_STDLIB=libc++" >> "$GITHUB_ENV"
-
       - name: Configure
         run: |
           mkdir build && cd build
diff --git a/tests/lit/lit/formats/Cpp2RustTest.py b/tests/lit/lit/formats/Cpp2RustTest.py
index 476d3874ea..5e77edae55 100644
--- a/tests/lit/lit/formats/Cpp2RustTest.py
+++ b/tests/lit/lit/formats/Cpp2RustTest.py
@@ -16,7 +16,6 @@
 
 
 MODELS = ("refcount", "unsafe")
-STDLIB = os.environ.get("CPP2RUST_STDLIB")
 PTR_RE = re.compile(r"0x[0-9a-fA-F]+")
 
 RE_XFAIL = re.compile(r"//\s*XFAIL:\s*(.*)")
@@ -110,8 +109,7 @@ def setup(cls, test):
             tmp_dir=tmp_dir,
             rs_file=tmp_dir / "main.rs",
             expectations=TestExpectations.parse(source_text, model),
-            extra_cxxflags=stdlib_flags(cc_input)
-            + parse_additional_compile_flags(source_text),
+            extra_cxxflags=parse_additional_compile_flags(source_text),
             replace_expected=bool(os.environ.get("REPLACE_EXPECTED", False)),
             skip_run=bool(os.environ.get("SKIP_RUN", False)),
         )
@@ -436,20 +434,12 @@ def setup_build_dir(tmp_dir, cc_input):
         str(build_dir),
         "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
     ]
-    if STDLIB:
-        cmd.append(f"-DCMAKE_CXX_FLAGS=-stdlib={STDLIB}")
     _, err, rc = lit.util.executeCommand(cmd)
     if rc != 0:
         return None, "cmake configure failed\n" + err
     return build_dir, None
 
 
-def stdlib_flags(cc_input):
-    if STDLIB and cc_input.suffix == ".cpp":
-        return [f"-stdlib={STDLIB}"]
-    return []
-
-
 def parse_additional_compile_flags(text):
     flags = []
     for m in RE_ADDITIONAL_COMPILE_FLAGS.finditer(text):

From abc9338d2aadc685bf1fdc42207f309c84f993be Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 14:26:19 +0100
Subject: [PATCH 21/34] Add standard-version ifdefs in rules

---
 rules/cstddef/src.cpp    | 4 ++++
 rules/new/src.cpp        | 2 ++
 rules/string/src.cpp     | 2 ++
 rules/unique_ptr/src.cpp | 4 ++++
 4 files changed, 12 insertions(+)

diff --git a/rules/cstddef/src.cpp b/rules/cstddef/src.cpp
index b53725844b..aa6fec4f3a 100644
--- a/rules/cstddef/src.cpp
+++ b/rules/cstddef/src.cpp
@@ -4,7 +4,9 @@
 #include <cstddef>
 #include <sys/types.h>
 
+#if __cplusplus >= 201703L
 using t1 = std::byte;
+#endif
 
 typedef size_t t2;
 typedef size_t *t3;
@@ -14,6 +16,7 @@ typedef ssize_t t6;
 typedef ssize_t *t7;
 typedef const ssize_t *t8;
 
+#if __cplusplus >= 201703L
 std::byte f1(const std::byte &a0, unsigned a1) { return operator<<(a0, a1); }
 
 std::byte f2(const std::byte &a0, unsigned a1) { return operator>>(a0, a1); }
@@ -21,3 +24,4 @@ std::byte f2(const std::byte &a0, unsigned a1) { return operator>>(a0, a1); }
 std::byte f3(std::byte &a0, unsigned a1) { return operator<<=(a0, a1); }
 
 std::byte f4(std::byte &a0, unsigned a1) { return operator>>=(a0, a1); }
+#endif
diff --git a/rules/new/src.cpp b/rules/new/src.cpp
index ea1a12ed09..fe9fd99ccb 100644
--- a/rules/new/src.cpp
+++ b/rules/new/src.cpp
@@ -11,4 +11,6 @@ void *f3(std::size_t a0) { return ::operator new[](a0); }
 
 void f4(void *a0) { return ::operator delete[](a0); }
 
+#if __cplusplus >= 201703L
 template <typename T1> T1 *f5(T1 *a0) { return std::launder(a0); }
+#endif
diff --git a/rules/string/src.cpp b/rules/string/src.cpp
index 276962df85..ea6f3a3a26 100644
--- a/rules/string/src.cpp
+++ b/rules/string/src.cpp
@@ -23,7 +23,9 @@ std::string &f4(std::string &s, const char *p, std::size_t n) {
 
 const char *f5(const std::string &s) { return s.c_str(); }
 
+#if __cplusplus >= 201703L
 char *f6(std::string &s) { return s.data(); }
+#endif
 
 std::string f7(const char *s, std::size_t n) { return std::string(s, n); }
 
diff --git a/rules/unique_ptr/src.cpp b/rules/unique_ptr/src.cpp
index 8f7c5458a3..98cd44181a 100644
--- a/rules/unique_ptr/src.cpp
+++ b/rules/unique_ptr/src.cpp
@@ -9,9 +9,11 @@ template <typename T, typename A> using Init = A;
 template <typename T1> using t1 = std::unique_ptr<T1>;
 template <typename T1> using t2 = std::unique_ptr<T1[]>;
 
+#if __cplusplus >= 201402L
 template <typename T2, typename T1> std::unique_ptr<T1[]> f1(std::size_t n) {
   return std::make_unique<T1[]>(n);
 }
+#endif
 
 template <typename T1> T1 *f2(std::unique_ptr<T1> &o) { return o.get(); }
 
@@ -33,10 +35,12 @@ template <typename T1> void f6(std::unique_ptr<T1[]> &o, T1 *p) {
 
 template <typename T1> T1 *f7(std::unique_ptr<T1[]> &o) { return o.get(); }
 
+#if __cplusplus >= 201402L
 template <typename T1, typename... Args>
 std::unique_ptr<T1> f8(Init<T1, Args> &&...args) {
   return std::make_unique<T1>(std::forward<Args>(args)...);
 }
+#endif
 
 template <typename T1> void f9(std::unique_ptr<T1[]> &o) {
   return o.reset(nullptr);

From f516529823f2199db32ffb5b9ff3f03642418f15 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 16:00:07 +0100
Subject: [PATCH 22/34] Add tyepofexprtype

---
 cpp2rust/converter/printer.cpp     |  4 ++++
 rules/arpa_inet/{src.cpp => src.c} |  0
 rules/brotli/{src.cpp => src.c}    | 10 +++++-----
 rules/cstddef/src.c                | 13 +++++++++++++
 rules/cstddef/src.cpp              |  9 ---------
 rules/dirent/{src.cpp => src.c}    |  4 ++--
 rules/fnmatch/{src.cpp => src.c}   |  0
 rules/ifaddrs/{src.cpp => src.c}   |  0
 rules/ip/{src.cpp => src.c}        |  0
 rules/locale/{src.cpp => src.c}    |  0
 rules/math/{src.cpp => src.c}      |  0
 rules/net_if/{src.cpp => src.c}    |  0
 rules/netdb/{src.cpp => src.c}     |  1 +
 rules/poll/{src.cpp => src.c}      |  0
 rules/pwd/{src.cpp => src.c}       |  1 +
 rules/select/src.c                 |  6 ++++++
 rules/select/src.cpp               |  2 --
 rules/signal/{src.cpp => src.c}    |  1 +
 rules/stat/{src.cpp => src.c}      |  1 +
 rules/stdio/src.c                  |  6 ++++++
 rules/stdio/src.cpp                |  2 --
 rules/termios/{src.cpp => src.c}   |  0
 rules/unistd/{src.cpp => src.c}    |  1 +
 23 files changed, 41 insertions(+), 20 deletions(-)
 rename rules/arpa_inet/{src.cpp => src.c} (100%)
 rename rules/brotli/{src.cpp => src.c} (95%)
 create mode 100644 rules/cstddef/src.c
 rename rules/dirent/{src.cpp => src.c} (86%)
 rename rules/fnmatch/{src.cpp => src.c} (100%)
 rename rules/ifaddrs/{src.cpp => src.c} (100%)
 rename rules/ip/{src.cpp => src.c} (100%)
 rename rules/locale/{src.cpp => src.c} (100%)
 rename rules/math/{src.cpp => src.c} (100%)
 rename rules/net_if/{src.cpp => src.c} (100%)
 rename rules/netdb/{src.cpp => src.c} (95%)
 rename rules/poll/{src.cpp => src.c} (100%)
 rename rules/pwd/{src.cpp => src.c} (94%)
 create mode 100644 rules/select/src.c
 rename rules/signal/{src.cpp => src.c} (92%)
 rename rules/stat/{src.cpp => src.c} (95%)
 create mode 100644 rules/stdio/src.c
 rename rules/termios/{src.cpp => src.c} (100%)
 rename rules/unistd/{src.cpp => src.c} (97%)

diff --git a/cpp2rust/converter/printer.cpp b/cpp2rust/converter/printer.cpp
index 38e39c282c..1e889eca68 100644
--- a/cpp2rust/converter/printer.cpp
+++ b/cpp2rust/converter/printer.cpp
@@ -128,6 +128,10 @@ std::string ToString(clang::ASTContext &ctx, clang::QualType qual_type,
             clang::dyn_cast<clang::DecltypeType>(t.getTypePtr())) {
       t = decltype_type->getUnderlyingType();
     }
+    if (const auto *typeof_type =
+            clang::dyn_cast<clang::TypeOfExprType>(t.getTypePtr())) {
+      t = typeof_type->getUnderlyingExpr()->getType();
+    }
     if (const auto *typedef_type = t->getAs<clang::TypedefType>()) {
       if (t.getCanonicalType()->isBuiltinType()) {
         return typedef_type->getDecl()->getNameAsString();
diff --git a/rules/arpa_inet/src.cpp b/rules/arpa_inet/src.c
similarity index 100%
rename from rules/arpa_inet/src.cpp
rename to rules/arpa_inet/src.c
diff --git a/rules/brotli/src.cpp b/rules/brotli/src.c
similarity index 95%
rename from rules/brotli/src.cpp
rename to rules/brotli/src.c
index 534d59cc19..ce1eb34e14 100644
--- a/rules/brotli/src.cpp
+++ b/rules/brotli/src.c
@@ -4,11 +4,11 @@
 #include "brotli/decode.h"
 #include "brotli/encode.h"
 
-using t1 = BrotliDecoderResult;
-using t2 = BrotliEncoderMode;
-using t3 = BrotliDecoderStateStruct *;
-using t4 = const BrotliDecoderStateStruct *;
-using t5 = BrotliDecoderErrorCode;
+typedef BrotliDecoderResult t1;
+typedef BrotliEncoderMode t2;
+typedef struct BrotliDecoderStateStruct *t3;
+typedef const struct BrotliDecoderStateStruct *t4;
+typedef BrotliDecoderErrorCode t5;
 
 BrotliEncoderMode f1() { return BROTLI_MODE_FONT; }
 
diff --git a/rules/cstddef/src.c b/rules/cstddef/src.c
new file mode 100644
index 0000000000..35b37dfab5
--- /dev/null
+++ b/rules/cstddef/src.c
@@ -0,0 +1,13 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <stddef.h>
+#include <sys/types.h>
+
+typedef size_t t2;
+typedef size_t *t3;
+typedef const size_t *t4;
+typedef __typeof__(sizeof(0)) t5;
+typedef ssize_t t6;
+typedef ssize_t *t7;
+typedef const ssize_t *t8;
diff --git a/rules/cstddef/src.cpp b/rules/cstddef/src.cpp
index b53725844b..9ae81ccd7f 100644
--- a/rules/cstddef/src.cpp
+++ b/rules/cstddef/src.cpp
@@ -2,18 +2,9 @@
 // Distributed under the MIT license that can be found in the LICENSE file.
 
 #include <cstddef>
-#include <sys/types.h>
 
 using t1 = std::byte;
 
-typedef size_t t2;
-typedef size_t *t3;
-typedef const size_t *t4;
-typedef decltype(sizeof(0)) t5;
-typedef ssize_t t6;
-typedef ssize_t *t7;
-typedef const ssize_t *t8;
-
 std::byte f1(const std::byte &a0, unsigned a1) { return operator<<(a0, a1); }
 
 std::byte f2(const std::byte &a0, unsigned a1) { return operator>>(a0, a1); }
diff --git a/rules/dirent/src.cpp b/rules/dirent/src.c
similarity index 86%
rename from rules/dirent/src.cpp
rename to rules/dirent/src.c
index f5b720e13e..75c18fed2b 100644
--- a/rules/dirent/src.cpp
+++ b/rules/dirent/src.c
@@ -3,8 +3,8 @@
 
 #include <dirent.h>
 
-using t1 = DIR *;
-using t2 = struct dirent;
+typedef DIR *t1;
+typedef struct dirent t2;
 
 DIR *f1(const char *name) { return opendir(name); }
 
diff --git a/rules/fnmatch/src.cpp b/rules/fnmatch/src.c
similarity index 100%
rename from rules/fnmatch/src.cpp
rename to rules/fnmatch/src.c
diff --git a/rules/ifaddrs/src.cpp b/rules/ifaddrs/src.c
similarity index 100%
rename from rules/ifaddrs/src.cpp
rename to rules/ifaddrs/src.c
diff --git a/rules/ip/src.cpp b/rules/ip/src.c
similarity index 100%
rename from rules/ip/src.cpp
rename to rules/ip/src.c
diff --git a/rules/locale/src.cpp b/rules/locale/src.c
similarity index 100%
rename from rules/locale/src.cpp
rename to rules/locale/src.c
diff --git a/rules/math/src.cpp b/rules/math/src.c
similarity index 100%
rename from rules/math/src.cpp
rename to rules/math/src.c
diff --git a/rules/net_if/src.cpp b/rules/net_if/src.c
similarity index 100%
rename from rules/net_if/src.cpp
rename to rules/net_if/src.c
diff --git a/rules/netdb/src.cpp b/rules/netdb/src.c
similarity index 95%
rename from rules/netdb/src.cpp
rename to rules/netdb/src.c
index ad0ccd2e0f..c49b27510e 100644
--- a/rules/netdb/src.cpp
+++ b/rules/netdb/src.c
@@ -1,6 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <netdb.h>
 
 typedef struct addrinfo t1;
diff --git a/rules/poll/src.cpp b/rules/poll/src.c
similarity index 100%
rename from rules/poll/src.cpp
rename to rules/poll/src.c
diff --git a/rules/pwd/src.cpp b/rules/pwd/src.c
similarity index 94%
rename from rules/pwd/src.cpp
rename to rules/pwd/src.c
index 12dbd3eec9..f612962f84 100644
--- a/rules/pwd/src.cpp
+++ b/rules/pwd/src.c
@@ -1,6 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <pwd.h>
 
 typedef struct passwd t1;
diff --git a/rules/select/src.c b/rules/select/src.c
new file mode 100644
index 0000000000..0c711faf92
--- /dev/null
+++ b/rules/select/src.c
@@ -0,0 +1,6 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <sys/select.h>
+
+typedef fd_set t1;
diff --git a/rules/select/src.cpp b/rules/select/src.cpp
index 9e2bcee672..0749f4d985 100644
--- a/rules/select/src.cpp
+++ b/rules/select/src.cpp
@@ -3,8 +3,6 @@
 
 #include <sys/select.h>
 
-using t1 = fd_set;
-
 int f1(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
        struct timeval *timeout) {
   return select(nfds, readfds, writefds, exceptfds, timeout);
diff --git a/rules/signal/src.cpp b/rules/signal/src.c
similarity index 92%
rename from rules/signal/src.cpp
rename to rules/signal/src.c
index 9ff7721822..618ab594dd 100644
--- a/rules/signal/src.cpp
+++ b/rules/signal/src.c
@@ -1,6 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <signal.h>
 
 int f1(int signum, const struct sigaction *act, struct sigaction *oldact) {
diff --git a/rules/stat/src.cpp b/rules/stat/src.c
similarity index 95%
rename from rules/stat/src.cpp
rename to rules/stat/src.c
index 5d79dfda38..eb642f227b 100644
--- a/rules/stat/src.cpp
+++ b/rules/stat/src.c
@@ -1,6 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <sys/stat.h>
 
 typedef struct stat t1;
diff --git a/rules/stdio/src.c b/rules/stdio/src.c
new file mode 100644
index 0000000000..4faccdae9d
--- /dev/null
+++ b/rules/stdio/src.c
@@ -0,0 +1,6 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <stdio.h>
+
+typedef FILE *t1;
diff --git a/rules/stdio/src.cpp b/rules/stdio/src.cpp
index 271233d21d..ffdd41f0b6 100644
--- a/rules/stdio/src.cpp
+++ b/rules/stdio/src.cpp
@@ -3,8 +3,6 @@
 
 #include <stdio.h>
 
-using t1 = FILE *;
-
 FILE *f1(const char *pathname, const char *mode) {
   return fopen(pathname, mode);
 }
diff --git a/rules/termios/src.cpp b/rules/termios/src.c
similarity index 100%
rename from rules/termios/src.cpp
rename to rules/termios/src.c
diff --git a/rules/unistd/src.cpp b/rules/unistd/src.c
similarity index 97%
rename from rules/unistd/src.cpp
rename to rules/unistd/src.c
index 7b0bd0f70a..b1a72ccbbb 100644
--- a/rules/unistd/src.cpp
+++ b/rules/unistd/src.c
@@ -1,6 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <unistd.h>
 
 int f1(int fd) { return close(fd); }

From 8f4f6a1204da532085c02c66f0630c71d218291a Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 16:04:54 +0100
Subject: [PATCH 23/34] Move select to C

---
 rules/select/src.c   | 10 ++++++++++
 rules/select/src.cpp | 14 --------------
 2 files changed, 10 insertions(+), 14 deletions(-)
 delete mode 100644 rules/select/src.cpp

diff --git a/rules/select/src.c b/rules/select/src.c
index 0c711faf92..d9f5bb0759 100644
--- a/rules/select/src.c
+++ b/rules/select/src.c
@@ -4,3 +4,13 @@
 #include <sys/select.h>
 
 typedef fd_set t1;
+
+int f1(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
+       struct timeval *timeout) {
+  return select(nfds, readfds, writefds, exceptfds, timeout);
+}
+
+void f2(int fd, fd_set *set) { return FD_SET(fd, set); }
+void f3(int fd, fd_set *set) { return FD_CLR(fd, set); }
+int f4(int fd, const fd_set *set) { return FD_ISSET(fd, set); }
+void f5(fd_set *set) { return FD_ZERO(set); }
diff --git a/rules/select/src.cpp b/rules/select/src.cpp
deleted file mode 100644
index 0749f4d985..0000000000
--- a/rules/select/src.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) 2022-present INESC-ID.
-// Distributed under the MIT license that can be found in the LICENSE file.
-
-#include <sys/select.h>
-
-int f1(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
-       struct timeval *timeout) {
-  return select(nfds, readfds, writefds, exceptfds, timeout);
-}
-
-void f2(int fd, fd_set *set) { return FD_SET(fd, set); }
-void f3(int fd, fd_set *set) { return FD_CLR(fd, set); }
-int f4(int fd, const fd_set *set) { return FD_ISSET(fd, set); }
-void f5(fd_set *set) { return FD_ZERO(set); }

From 5c488d442a5d0ff5bd828e0d6be01ad68cde5684 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 16:08:44 +0100
Subject: [PATCH 24/34] Move more things in src.c

---
 cpp2rust/cpp_rule_preprocessor.cpp | 15 ++++++
 rules/fcntl/{src.cpp => src.c}     | 11 ++---
 rules/ioctl/{src.cpp => src.c}     |  5 +-
 rules/stdio/src.c                  | 71 +++++++++++++++++++++++++++
 rules/stdio/src.cpp                | 77 ------------------------------
 5 files changed, 90 insertions(+), 89 deletions(-)
 rename rules/fcntl/{src.cpp => src.c} (67%)
 rename rules/ioctl/{src.cpp => src.c} (55%)
 delete mode 100644 rules/stdio/src.cpp

diff --git a/cpp2rust/cpp_rule_preprocessor.cpp b/cpp2rust/cpp_rule_preprocessor.cpp
index cff775b803..edd3146f97 100644
--- a/cpp2rust/cpp_rule_preprocessor.cpp
+++ b/cpp2rust/cpp_rule_preprocessor.cpp
@@ -117,6 +117,14 @@ class Callback : public clang::ast_matchers::MatchFinder::MatchCallback {
       }
       return;
     }
+    if (auto var = R.Nodes.getNodeAs<clang::VarDecl>("fvar")) {
+      out_.try_emplace(
+          var->getQualifiedNameAsString(),
+          Printer::ToString(*R.Context,
+                            R.Nodes.getNodeAs<clang::FunctionDecl>("fn")));
+      return;
+    }
+
     if (auto var = R.Nodes.getNodeAs<clang::TypedefNameDecl>("tvar")) {
       clang::QualType type = var->getUnderlyingType();
       if (auto *alias = llvm::dyn_cast<clang::TypeAliasDecl>(var)) {
@@ -999,6 +1007,13 @@ class ActionFactory : public clang::tooling::FrontendActionFactory {
             .bind("tvar"),
         &cb_);
 
+    finder_.addMatcher(
+        varDecl(matchesName("(^|::)f[0-9]+$"), isExpansionInMainFile(),
+                hasInitializer(ignoringImplicit(ignoringParenImpCasts(
+                    declRefExpr(to(functionDecl().bind("fn")))))))
+            .bind("fvar"),
+        &cb_);
+
     finder_.addMatcher(functionDecl(isDefinition(),
                                     matchesName("(^|::)f[0-9]+$"),
                                     isExpansionInMainFile())
diff --git a/rules/fcntl/src.cpp b/rules/fcntl/src.c
similarity index 67%
rename from rules/fcntl/src.cpp
rename to rules/fcntl/src.c
index ac5fb3351c..f23c71aec7 100644
--- a/rules/fcntl/src.cpp
+++ b/rules/fcntl/src.c
@@ -1,17 +1,12 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <fcntl.h>
 
-template <typename... Args>
-int f1(int a0, int a1, Args... args) {
-  return fcntl(a0, a1, args...);
-}
+int (*f1)(int, int, ...) = fcntl;
 
-template <typename... Args>
-int f2(const char *a0, int a1, Args... args) {
-  return open(a0, a1, args...);
-}
+int (*f2)(const char *, int, ...) = open;
 
 int f3(void) { return O_CREAT; }
 int f4(void) { return O_TRUNC; }
diff --git a/rules/ioctl/src.cpp b/rules/ioctl/src.c
similarity index 55%
rename from rules/ioctl/src.cpp
rename to rules/ioctl/src.c
index 02587ce47c..fe322aec32 100644
--- a/rules/ioctl/src.cpp
+++ b/rules/ioctl/src.c
@@ -3,7 +3,4 @@
 
 #include <sys/ioctl.h>
 
-template <typename... Args>
-int f1(int a0, unsigned long a1, Args... args) {
-  return ioctl(a0, a1, args...);
-}
+int (*f1)(int, unsigned long, ...) = ioctl;
diff --git a/rules/stdio/src.c b/rules/stdio/src.c
index 4faccdae9d..1a2419033e 100644
--- a/rules/stdio/src.c
+++ b/rules/stdio/src.c
@@ -1,6 +1,77 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
+#define _GNU_SOURCE
 #include <stdio.h>
 
 typedef FILE *t1;
+
+FILE *f1(const char *pathname, const char *mode) {
+  return fopen(pathname, mode);
+}
+
+int f2(FILE *stream) { return fclose(stream); }
+
+long f3(FILE *stream) { return ftell(stream); }
+
+int f4(FILE *stream, long offset, int whence) {
+  return fseek(stream, offset, whence);
+}
+
+size_t f5(void *ptr, size_t size, size_t nmemb, FILE *stream) {
+  return fread(ptr, size, nmemb, stream);
+}
+
+size_t f6(const void *ptr, size_t size, size_t nmemb, FILE *stream) {
+  return fwrite(ptr, size, nmemb, stream);
+}
+
+int f7(FILE *stream) { return fflush(stream); }
+
+FILE *f8() { return stdout; }
+
+FILE *f9() { return stderr; }
+
+FILE *f10() { return stdin; }
+
+int f11(int c, FILE *stream) { return fputc(c, stream); }
+
+int f12(const char *s, FILE *stream) { return fputs(s, stream); }
+
+int f13(const char *s) { return puts(s); }
+
+int f14(FILE *stream) { return fileno(stream); }
+
+int f15(FILE *stream) { return ferror(stream); }
+
+int f16(FILE *stream) { return feof(stream); }
+
+char *f17(char *s, int n, FILE *stream) { return fgets(s, n, stream); }
+
+FILE *f18(const char *pathname, const char *mode, FILE *stream) {
+  return freopen(pathname, mode, stream);
+}
+
+int f19(FILE *stream, off_t offset, int whence) {
+  return fseeko(stream, offset, whence);
+}
+
+FILE *f20(int fd, const char *mode) { return fdopen(fd, mode); }
+
+int (*f21)(char *, size_t, const char *, ...) = snprintf;
+
+int f22(const char *a0, const char *a1) {
+  return rename(a0, a1);
+}
+
+int f23(FILE *stream) { return getc(stream); }
+
+int f24(FILE *stream, char *buf, int mode, size_t size) {
+  return setvbuf(stream, buf, mode, size);
+}
+
+int f25(void) { return SEEK_SET; }
+
+int f26(void) { return SEEK_CUR; }
+
+int f27(void) { return SEEK_END; }
diff --git a/rules/stdio/src.cpp b/rules/stdio/src.cpp
deleted file mode 100644
index ffdd41f0b6..0000000000
--- a/rules/stdio/src.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) 2022-present INESC-ID.
-// Distributed under the MIT license that can be found in the LICENSE file.
-
-#include <stdio.h>
-
-FILE *f1(const char *pathname, const char *mode) {
-  return fopen(pathname, mode);
-}
-
-int f2(FILE *stream) { return fclose(stream); }
-
-long f3(FILE *stream) { return ftell(stream); }
-
-int f4(FILE *stream, long offset, int whence) {
-  return fseek(stream, offset, whence);
-}
-
-size_t f5(void *ptr, size_t size, size_t nmemb, FILE *stream) {
-  return fread(ptr, size, nmemb, stream);
-}
-
-size_t f6(const void *ptr, size_t size, size_t nmemb, FILE *stream) {
-  return fwrite(ptr, size, nmemb, stream);
-}
-
-int f7(FILE *stream) { return fflush(stream); }
-
-FILE *f8() { return stdout; }
-
-FILE *f9() { return stderr; }
-
-FILE *f10() { return stdin; }
-
-int f11(int c, FILE *stream) { return fputc(c, stream); }
-
-int f12(const char *s, FILE *stream) { return fputs(s, stream); }
-
-int f13(const char *s) { return puts(s); }
-
-int f14(FILE *stream) { return fileno(stream); }
-
-int f15(FILE *stream) { return ferror(stream); }
-
-int f16(FILE *stream) { return feof(stream); }
-
-char *f17(char *s, int n, FILE *stream) { return fgets(s, n, stream); }
-
-FILE *f18(const char *pathname, const char *mode, FILE *stream) {
-  return freopen(pathname, mode, stream);
-}
-
-int f19(FILE *stream, off_t offset, int whence) {
-  return fseeko(stream, offset, whence);
-}
-
-FILE *f20(int fd, const char *mode) { return fdopen(fd, mode); }
-
-template <typename... Args>
-int f21(char *a0, size_t a1, const char *a2, Args... args) {
-  return snprintf(a0, a1, a2, args...);
-}
-
-int f22(const char *a0, const char *a1) {
-  return rename(a0, a1);
-}
-
-int f23(FILE *stream) { return getc(stream); }
-
-int f24(FILE *stream, char *buf, int mode, size_t size) {
-  return setvbuf(stream, buf, mode, size);
-}
-
-int f25(void) { return SEEK_SET; }
-
-int f26(void) { return SEEK_CUR; }
-
-int f27(void) { return SEEK_END; }

From 47c7534c138645a4bddfcae0499431b39a7633b9 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sat, 3 Oct 2026 16:19:53 +0100
Subject: [PATCH 25/34] Use rules as system header

---
 CMakeLists.txt     | 2 +-
 rules/brotli/src.c | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index cf4cf7a501..9589f71032 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -225,7 +225,7 @@ foreach(_rule_dir IN LISTS rule_subdirs)
   get_filename_component(_rule_name ${_rule_dir} NAME)
   set(_out_dir ${RULES_IR_DIR}/${_rule_name})
   set(_cpp_out ${_out_dir}/ir_src.json)
-  set(_cxxflags)
+  set(_cxxflags --cxxflags=-isystem${_rule_dir})
   set(_cxxflags_file)
   if(EXISTS ${_rule_dir}/cxxflags)
     set(_cxxflags_file ${_rule_dir}/cxxflags)
diff --git a/rules/brotli/src.c b/rules/brotli/src.c
index ce1eb34e14..6f8c177968 100644
--- a/rules/brotli/src.c
+++ b/rules/brotli/src.c
@@ -1,8 +1,8 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-#include "brotli/decode.h"
-#include "brotli/encode.h"
+#include <brotli/decode.h>
+#include <brotli/encode.h>
 
 typedef BrotliDecoderResult t1;
 typedef BrotliEncoderMode t2;

From e2fe03990dd1304c2c3a70064215ffcdc7769f7d Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sun, 4 Oct 2026 10:21:30 +0100
Subject: [PATCH 26/34] Move more C specific rules in src.c

---
 rules/assert/{src.cpp => src.c}  |  0
 rules/builtin/src.c              | 40 ++++++++++++++++++++++++++++++++
 rules/builtin/src.cpp            | 37 -----------------------------
 rules/builtin_types/src.cpp      | 18 --------------
 rules/cstdlib/{src.cpp => src.c} |  4 ++--
 5 files changed, 42 insertions(+), 57 deletions(-)
 rename rules/assert/{src.cpp => src.c} (100%)
 rename rules/cstdlib/{src.cpp => src.c} (94%)

diff --git a/rules/assert/src.cpp b/rules/assert/src.c
similarity index 100%
rename from rules/assert/src.cpp
rename to rules/assert/src.c
diff --git a/rules/builtin/src.c b/rules/builtin/src.c
index 805fbc1c5a..afe0231a9a 100644
--- a/rules/builtin/src.c
+++ b/rules/builtin/src.c
@@ -1,2 +1,42 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <stddef.h>
+
+#if defined(__linux__)
+#include <byteswap.h>
+#elif !defined(__APPLE__)
+#error "Unsupported platform"
+#endif
+
+long f1(long exp, long c) { return __builtin_expect(exp, c); }
+int f2(unsigned int x) { return __builtin_ctz(x); }
+int f3(unsigned int x) { return __builtin_clz(x); }
+#if defined(__linux__)
+unsigned short f4(unsigned short x) { return bswap_16(x); }
+unsigned int f5(unsigned int x) { return bswap_32(x); }
+unsigned long long f6(unsigned long long x) { return bswap_64(x); }
+#elif defined(__APPLE__)
+unsigned short f4(unsigned short x) { return __builtin_bswap16(x); }
+unsigned int f5(unsigned int x) { return __builtin_bswap32(x); }
+unsigned long long f6(unsigned long long x) { return __builtin_bswap64(x); }
+#endif
+int f7(unsigned long x) { return __builtin_ctzl(x); }
+int f8(unsigned long x) { return __builtin_popcountl(x); }
 int f12(long a, long b, long *r) { return __builtin_mul_overflow(a, b, r); }
 int f13(long long a, long long b, long long *r) { return __builtin_mul_overflow(a, b, r); }
+#if defined(__x86_64__) || defined(__i386__)
+void f11(void) { return __builtin_ia32_pause(); }
+#endif
+
+void *f14(void *dst, const void *src, size_t n) {
+  return __builtin_memcpy(dst, src, n);
+}
+
+void f15() { return __builtin_abort(); }
+
+int f16(unsigned long x) { return __builtin_clzl(x); }
+
+float f17() { return __builtin_inff(); }
+
+float f18(const char *tagp) { return __builtin_nanf(tagp); }
diff --git a/rules/builtin/src.cpp b/rules/builtin/src.cpp
index caf010941e..ecf42baf90 100644
--- a/rules/builtin/src.cpp
+++ b/rules/builtin/src.cpp
@@ -1,42 +1,5 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-#include <stddef.h>
-
-#if defined(__linux__)
-#include <byteswap.h>
-#elif !defined(__APPLE__)
-#error "Unsupported platform"
-#endif
-
-long f1(long exp, long c) { return __builtin_expect(exp, c); }
-int f2(unsigned int x) { return __builtin_ctz(x); }
-int f3(unsigned int x) { return __builtin_clz(x); }
-#if defined(__linux__)
-unsigned short f4(unsigned short x) { return bswap_16(x); }
-unsigned int f5(unsigned int x) { return bswap_32(x); }
-unsigned long long f6(unsigned long long x) { return bswap_64(x); }
-#elif defined(__APPLE__)
-unsigned short f4(unsigned short x) { return __builtin_bswap16(x); }
-unsigned int f5(unsigned int x) { return __builtin_bswap32(x); }
-unsigned long long f6(unsigned long long x) { return __builtin_bswap64(x); }
-#endif
-int f7(unsigned long x) { return __builtin_ctzl(x); }
-int f8(unsigned long x) { return __builtin_popcountl(x); }
 bool f9(long a, long b, long *r) { return __builtin_mul_overflow(a, b, r); }
 bool f10(long long a, long long b, long long *r) { return __builtin_mul_overflow(a, b, r); }
-#if defined(__x86_64__) || defined(__i386__)
-void f11(void) { return __builtin_ia32_pause(); }
-#endif
-
-void *f14(void *dst, const void *src, size_t n) {
-  return __builtin_memcpy(dst, src, n);
-}
-
-void f15() { return __builtin_abort(); }
-
-int f16(unsigned long x) { return __builtin_clzl(x); }
-
-float f17() { return __builtin_inff(); }
-
-float f18(const char *tagp) { return __builtin_nanf(tagp); }
diff --git a/rules/builtin_types/src.cpp b/rules/builtin_types/src.cpp
index ee504e2130..5cc5235abc 100644
--- a/rules/builtin_types/src.cpp
+++ b/rules/builtin_types/src.cpp
@@ -12,27 +12,9 @@
 
 typedef decltype(nullptr) t0;
 
-BUILTIN_TYPE(1, bool)
-BUILTIN_TYPE(2, char)
-BUILTIN_TYPE(3, signed char)
-BUILTIN_TYPE(4, unsigned char)
 BUILTIN_TYPE(5, char8_t)
-BUILTIN_TYPE(6, short)
-BUILTIN_TYPE(7, unsigned short)
 BUILTIN_TYPE(8, char16_t)
-BUILTIN_TYPE(9, int)
-BUILTIN_TYPE(10, unsigned int)
 BUILTIN_TYPE(11, wchar_t)
 BUILTIN_TYPE(12, char32_t)
-BUILTIN_TYPE(13, float)
-BUILTIN_TYPE(14, long)
-BUILTIN_TYPE(15, unsigned long)
-BUILTIN_TYPE(16, long long)
-BUILTIN_TYPE(17, unsigned long long)
-BUILTIN_TYPE(18, double)
-BUILTIN_TYPE(19, long double)
-BUILTIN_TYPE(20, __int128)
-BUILTIN_TYPE(21, unsigned __int128)
-BUILTIN_TYPE(22, void)
 
 #undef BUILTIN_TYPE
diff --git a/rules/cstdlib/src.cpp b/rules/cstdlib/src.c
similarity index 94%
rename from rules/cstdlib/src.cpp
rename to rules/cstdlib/src.c
index cc8f44337c..5c75eaf711 100644
--- a/rules/cstdlib/src.cpp
+++ b/rules/cstdlib/src.c
@@ -1,9 +1,9 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-#include <cstdlib>
+#include <stdlib.h>
 
-void f1() { return std::abort(); }
+void f1() { return abort(); }
 
 void f2(void *a0) { return free(a0); }
 

From ef1b143fab284ca5584c5e8e77315ee83ffa8b15 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sun, 4 Oct 2026 10:22:08 +0100
Subject: [PATCH 27/34] Don't include C++ rules in C mode

---
 cpp2rust/converter/rules/matcher.cpp    |  6 +----
 cpp2rust/converter/rules/rule_decls.cpp | 32 +++++++------------------
 cpp2rust/converter/rules/rule_decls.h   |  1 -
 cpp2rust/rules_prelude.cpp              |  4 +---
 4 files changed, 10 insertions(+), 33 deletions(-)

diff --git a/cpp2rust/converter/rules/matcher.cpp b/cpp2rust/converter/rules/matcher.cpp
index 3458762e7c..402890cef6 100644
--- a/cpp2rust/converter/rules/matcher.cpp
+++ b/cpp2rust/converter/rules/matcher.cpp
@@ -364,7 +364,6 @@ Bindings getBindings(const clang::TemplateParameterList *params,
 
 struct Candidate {
   TranslationRule::ExprRule *rule = nullptr;
-  bool native = true;
   clang::QualType init_type;
   clang::FunctionTemplateDecl *tmpl = nullptr;
   clang::FunctionDecl *specialization = nullptr;
@@ -372,9 +371,6 @@ struct Candidate {
 
 bool isBetter(clang::Sema &sema, const Candidate &a, const Candidate &b,
               clang::SourceLocation loc, unsigned num_operands) {
-  if (a.native != b.native) {
-    return a.native;
-  }
   if (!a.tmpl || !b.tmpl) {
     return !a.tmpl && b.tmpl;
   }
@@ -401,7 +397,7 @@ ExprMatch findExpr(clang::ASTContext &ctx, const clang::Expr *expr,
   Candidate best;
   auto consider = [&](const std::string &bucket) {
     for (auto &[_, entry] : RuleDecls::ExprCandidates(bucket)) {
-      Candidate candidate{entry.rule, entry.native, entry.init_type};
+      Candidate candidate{entry.rule, entry.init_type};
       auto *function = const_cast<clang::FunctionDecl *>(entry.decl);
       if (auto *tmpl =
               function ? function->getDescribedFunctionTemplate() : nullptr) {
diff --git a/cpp2rust/converter/rules/rule_decls.cpp b/cpp2rust/converter/rules/rule_decls.cpp
index 944e325d31..3a2f25eeea 100644
--- a/cpp2rust/converter/rules/rule_decls.cpp
+++ b/cpp2rust/converter/rules/rule_decls.cpp
@@ -42,28 +42,21 @@ bool isRuleName(std::string_view name, char kind) {
 struct RuleId {
   std::string module;
   std::string name;
-  bool native = true;
 };
 
 std::optional<RuleId> getRuleId(const clang::NamedDecl *decl) {
   if (!decl->getIdentifier()) {
     return std::nullopt;
   }
-  constexpr std::string_view kOther = "other";
   std::string_view name = decl->getName();
   if (const auto *ns =
           llvm::dyn_cast<clang::NamespaceDecl>(decl->getDeclContext())) {
-    bool native = true;
-    if (ns->getIdentifier() && std::string_view(ns->getName()) == kOther) {
-      native = false;
-      ns = llvm::dyn_cast<clang::NamespaceDecl>(ns->getDeclContext());
-    }
-    std::string_view module = ns && ns->getIdentifier() ? ns->getName() : "";
+    std::string_view module = ns->getIdentifier() ? ns->getName() : "";
     if (!module.starts_with(kPrefix)) {
       return std::nullopt;
     }
-    return RuleId{std::string(module.substr(kPrefix.size())), std::string(name),
-                  native};
+    return RuleId{std::string(module.substr(kPrefix.size())),
+                  std::string(name)};
   }
   if (!name.starts_with(kPrefix)) {
     return std::nullopt;
@@ -73,13 +66,8 @@ std::optional<RuleId> getRuleId(const clang::NamedDecl *decl) {
   if (split == std::string_view::npos) {
     return std::nullopt;
   }
-  auto module = name.substr(0, split);
-  bool native = !module.ends_with("_other");
-  if (!native) {
-    module.remove_suffix(kOther.size() + 1);
-  }
-  return RuleId{std::string(module), std::string(name.substr(split + 1)),
-                native};
+  return RuleId{std::string(name.substr(0, split)),
+                std::string(name.substr(split + 1))};
 }
 
 } // namespace
@@ -368,8 +356,7 @@ void addExprRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
     auto key = GetExprKey(ctx, init);
     log() << "rule " << id->module << "::" << id->name << " -> '" << key
           << "'\n";
-    exprs_.emplace(std::move(key),
-                   ExprRuleDecl{nullptr, init, rule, id->native, {}});
+    exprs_.emplace(std::move(key), ExprRuleDecl{nullptr, init, rule, {}});
     return;
   }
   const clang::FunctionDecl *function = nullptr;
@@ -396,8 +383,7 @@ void addExprRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
   auto key = GetExprKey(ctx, returned);
   log() << "rule " << id->module << "::" << id->name << " -> '" << key << "'\n";
   exprs_.emplace(std::move(key),
-                 ExprRuleDecl{function, returned, rule, id->native,
-                              getInitType(function)});
+                 ExprRuleDecl{function, returned, rule, getInitType(function)});
 }
 
 void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
@@ -470,9 +456,7 @@ void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
 void addRules(clang::ASTContext &ctx, const clang::DeclContext *context) {
   for (const auto *child : context->decls()) {
     if (const auto *ns = llvm::dyn_cast<clang::NamespaceDecl>(child)) {
-      if (ns->getIdentifier() && (ns->getName().starts_with(kPrefix) ||
-                                  (ns->getName() == "other" &&
-                                   context != ctx.getTranslationUnitDecl()))) {
+      if (ns->getIdentifier() && ns->getName().starts_with(kPrefix)) {
         addRules(ctx, ns);
       }
       continue;
diff --git a/cpp2rust/converter/rules/rule_decls.h b/cpp2rust/converter/rules/rule_decls.h
index 2c1ad0fa18..d31f61d79e 100644
--- a/cpp2rust/converter/rules/rule_decls.h
+++ b/cpp2rust/converter/rules/rule_decls.h
@@ -19,7 +19,6 @@ struct ExprRuleDecl {
   const clang::FunctionDecl *decl;
   const clang::Expr *returned;
   TranslationRule::ExprRule *rule;
-  bool native;
   clang::QualType init_type;
 };
 
diff --git a/cpp2rust/rules_prelude.cpp b/cpp2rust/rules_prelude.cpp
index 480c4885af..371f6d0808 100644
--- a/cpp2rust/rules_prelude.cpp
+++ b/cpp2rust/rules_prelude.cpp
@@ -89,9 +89,8 @@ void addCxxModule(std::string &out, const fs::path &module_dir) {
   out += std::format("namespace cpp2rust_rules_{} {{\n",
                      module_dir.filename().string());
   out += withoutIncludes(readFile(module_dir / "src.cpp"));
-  out += "namespace other {\n";
   out += withoutIncludes(readFile(module_dir / "src.c"));
-  out += "}\n}\n";
+  out += "}\n";
 }
 
 void addCRules(std::string &out, const std::string &prefix,
@@ -109,7 +108,6 @@ void addCRules(std::string &out, const std::string &prefix,
 void addCModule(std::string &out, const fs::path &module_dir) {
   auto prefix = "cpp2rust_rules_" + module_dir.filename().string();
   addCRules(out, prefix, readFile(module_dir / "src.c"));
-  addCRules(out, prefix + "_other", readFile(module_dir / "src.cpp"));
 }
 
 } // namespace

From cb07afe1f7b8e0d552d627a4d2e807e2740f5e21 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sun, 4 Oct 2026 10:24:04 +0100
Subject: [PATCH 28/34] Handle bool in C vs C++ mode

---
 rules/builtin_types/src.c   | 2 ++
 rules/builtin_types/src.cpp | 1 +
 2 files changed, 3 insertions(+)

diff --git a/rules/builtin_types/src.c b/rules/builtin_types/src.c
index 680e1de594..e32961311a 100644
--- a/rules/builtin_types/src.c
+++ b/rules/builtin_types/src.c
@@ -8,7 +8,9 @@
   typedef volatile T *N3;                                                      \
   typedef const volatile T *N4;
 
+#ifndef __cplusplus
 BUILTIN_TYPE(_Bool, t10, t11, t12, t13, t14)
+#endif
 BUILTIN_TYPE(char, t20, t21, t22, t23, t24)
 BUILTIN_TYPE(signed char, t30, t31, t32, t33, t34)
 BUILTIN_TYPE(unsigned char, t40, t41, t42, t43, t44)
diff --git a/rules/builtin_types/src.cpp b/rules/builtin_types/src.cpp
index 5cc5235abc..cc858b186e 100644
--- a/rules/builtin_types/src.cpp
+++ b/rules/builtin_types/src.cpp
@@ -12,6 +12,7 @@
 
 typedef decltype(nullptr) t0;
 
+BUILTIN_TYPE(1, bool)
 BUILTIN_TYPE(5, char8_t)
 BUILTIN_TYPE(8, char16_t)
 BUILTIN_TYPE(11, wchar_t)

From 2c793b4c52e49258ea228c4d9843de63b40b300c Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sun, 4 Oct 2026 10:26:04 +0100
Subject: [PATCH 29/34] Revert unchanged code

---
 cpp2rust/converter/converter.cpp | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 12becfca28..f832673ffc 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -334,16 +334,13 @@ bool Converter::Convert(clang::Decl *decl) { return TraverseDecl(decl); }
 
 bool Converter::VisitTranslationUnitDecl(clang::TranslationUnitDecl *decl) {
   for (auto *child : decl->decls()) {
-    if (!IsUserDefinedDecl(child)) {
-      continue;
-    }
-    if (!IsInMainFile(child) && decl_ids_.contains(GetID(child))) {
-      continue;
-    }
-    Convert(child);
-    if (!hoisted_records_.empty()) {
-      StrCat(hoisted_records_);
-      hoisted_records_.clear();
+    if (IsUserDefinedDecl(child) &&
+        (IsInMainFile(child) || !decl_ids_.contains(GetID(child)))) {
+      Convert(child);
+      if (!hoisted_records_.empty()) {
+        StrCat(hoisted_records_);
+        hoisted_records_.clear();
+      }
     }
   }
   return false;

From feb2c1985a7e1a82f1a25d6a7ce4dd78f08735d6 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sun, 4 Oct 2026 10:27:43 +0100
Subject: [PATCH 30/34] Don't use module to describe rules

---
 cpp2rust/converter/rules/registry.cpp   | 14 ++++----
 cpp2rust/converter/rules/registry.h     |  4 +--
 cpp2rust/converter/rules/rule_decls.cpp | 43 ++++++++++++-------------
 cpp2rust/rules_prelude.cpp              | 30 ++++++++---------
 4 files changed, 45 insertions(+), 46 deletions(-)

diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp
index 57c653cd15..d667158b3e 100644
--- a/cpp2rust/converter/rules/registry.cpp
+++ b/cpp2rust/converter/rules/registry.cpp
@@ -49,12 +49,12 @@ void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
       log() << "No rules found in " << path << '\n';
       continue;
     }
-    auto module = path.filename().string();
+    auto rule_dir = path.filename().string();
     for (auto &[name, rule] : expr_rules) {
-      exprs_.emplace(module + '/' + name, std::move(rule));
+      exprs_.emplace(rule_dir + '/' + name, std::move(rule));
     }
     for (auto &[name, rule] : type_rules) {
-      types_.emplace(module + '/' + name, std::move(rule));
+      types_.emplace(rule_dir + '/' + name, std::move(rule));
     }
   }
 }
@@ -68,15 +68,15 @@ GetParamInfo(clang::ASTContext &ctx, const clang::Expr *expr, unsigned index) {
 
 } // namespace
 
-TranslationRule::ExprRule *FindExprRule(const std::string &module,
+TranslationRule::ExprRule *FindExprRule(const std::string &dir,
                                         const std::string &name) {
-  auto it = exprs_.find(module + '/' + name);
+  auto it = exprs_.find(dir + '/' + name);
   return it == exprs_.end() ? nullptr : &it->second;
 }
 
-TranslationRule::TypeRule *FindTypeRule(const std::string &module,
+TranslationRule::TypeRule *FindTypeRule(const std::string &dir,
                                         const std::string &name) {
-  auto it = types_.find(module + '/' + name);
+  auto it = types_.find(dir + '/' + name);
   return it == types_.end() ? nullptr : &it->second;
 }
 
diff --git a/cpp2rust/converter/rules/registry.h b/cpp2rust/converter/rules/registry.h
index 2134252e3b..3412303988 100644
--- a/cpp2rust/converter/rules/registry.h
+++ b/cpp2rust/converter/rules/registry.h
@@ -18,10 +18,10 @@
 #include "converter/translation_rule.h"
 
 namespace cpp2rust::RuleRegistry {
-TranslationRule::ExprRule *FindExprRule(const std::string &module,
+TranslationRule::ExprRule *FindExprRule(const std::string &dir,
                                         const std::string &name);
 
-TranslationRule::TypeRule *FindTypeRule(const std::string &module,
+TranslationRule::TypeRule *FindTypeRule(const std::string &dir,
                                         const std::string &name);
 
 TranslationRule::TypeRule *FindUserType(clang::ASTContext &ctx,
diff --git a/cpp2rust/converter/rules/rule_decls.cpp b/cpp2rust/converter/rules/rule_decls.cpp
index 3a2f25eeea..35bd09acb0 100644
--- a/cpp2rust/converter/rules/rule_decls.cpp
+++ b/cpp2rust/converter/rules/rule_decls.cpp
@@ -40,7 +40,7 @@ bool isRuleName(std::string_view name, char kind) {
 }
 
 struct RuleId {
-  std::string module;
+  std::string dir;
   std::string name;
 };
 
@@ -51,12 +51,11 @@ std::optional<RuleId> getRuleId(const clang::NamedDecl *decl) {
   std::string_view name = decl->getName();
   if (const auto *ns =
           llvm::dyn_cast<clang::NamespaceDecl>(decl->getDeclContext())) {
-    std::string_view module = ns->getIdentifier() ? ns->getName() : "";
-    if (!module.starts_with(kPrefix)) {
+    std::string_view dir = ns->getIdentifier() ? ns->getName() : "";
+    if (!dir.starts_with(kPrefix)) {
       return std::nullopt;
     }
-    return RuleId{std::string(module.substr(kPrefix.size())),
-                  std::string(name)};
+    return RuleId{std::string(dir.substr(kPrefix.size())), std::string(name)};
   }
   if (!name.starts_with(kPrefix)) {
     return std::nullopt;
@@ -328,13 +327,13 @@ void checkGenerics(const RuleId &id, const clang::FunctionDecl *function,
   }
   for (size_t i = 0, e = rule.generics.size(); i < e; ++i) {
     if (!declared[i + 1]) {
-      llvm::errs() << id.module << "::" << id.name << ": generic T" << (i + 1)
+      llvm::errs() << id.dir << "::" << id.name << ": generic T" << (i + 1)
                    << " declared but missing from src\n";
       llvm::report_fatal_error("Absent generic from src");
     }
   }
   if (rule.usesInit() && getInitType(function).isNull()) {
-    llvm::errs() << id.module << "::" << id.name << '\n';
+    llvm::errs() << id.dir << "::" << id.name << '\n';
     llvm::report_fatal_error(
         "Expr rule uses init but its src pack is not declared as Init<T, "
         "Args>");
@@ -348,13 +347,13 @@ void addExprRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
   }
   if (const auto *var = llvm::dyn_cast<clang::VarDecl>(decl)) {
     const auto *init = var->getInit();
-    auto *rule = RuleRegistry::FindExprRule(id->module, id->name);
+    auto *rule = RuleRegistry::FindExprRule(id->dir, id->name);
     if (var->isInvalidDecl() || !init || init->containsErrors() || !rule) {
-      log() << "rule " << id->module << "::" << id->name << " does not apply\n";
+      log() << "rule " << id->dir << "::" << id->name << " does not apply\n";
       return;
     }
     auto key = GetExprKey(ctx, init);
-    log() << "rule " << id->module << "::" << id->name << " -> '" << key
+    log() << "rule " << id->dir << "::" << id->name << " -> '" << key
           << "'\n";
     exprs_.emplace(std::move(key), ExprRuleDecl{nullptr, init, rule, {}});
     return;
@@ -371,17 +370,17 @@ void addExprRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
   const auto *returned = GetReturned(function);
   if (decl->isInvalidDecl() || function->isInvalidDecl() || !returned ||
       returned->containsErrors() || refersToUndeclared(returned)) {
-    log() << "rule " << id->module << "::" << id->name << " does not apply\n";
+    log() << "rule " << id->dir << "::" << id->name << " does not apply\n";
     return;
   }
-  auto *rule = RuleRegistry::FindExprRule(id->module, id->name);
+  auto *rule = RuleRegistry::FindExprRule(id->dir, id->name);
   if (!rule) {
-    log() << "rule " << id->module << "::" << id->name << " has no target\n";
+    log() << "rule " << id->dir << "::" << id->name << " has no target\n";
     return;
   }
   checkGenerics(*id, function, *rule);
   auto key = GetExprKey(ctx, returned);
-  log() << "rule " << id->module << "::" << id->name << " -> '" << key << "'\n";
+  log() << "rule " << id->dir << "::" << id->name << " -> '" << key << "'\n";
   exprs_.emplace(std::move(key),
                  ExprRuleDecl{function, returned, rule, getInitType(function)});
 }
@@ -392,8 +391,8 @@ void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
     return;
   }
   if (llvm::isa<clang::FunctionTemplateDecl>(decl)) {
-    if (auto *rule = RuleRegistry::FindTypeRule(id->module, id->name)) {
-      log() << "rule " << id->module << "::" << id->name << " -> ''\n";
+    if (auto *rule = RuleRegistry::FindTypeRule(id->dir, id->name)) {
+      log() << "rule " << id->dir << "::" << id->name << " -> ''\n";
       types_.emplace("", TypeRuleDecl{decl, rule});
     }
     return;
@@ -410,16 +409,16 @@ void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
   if (decl->isInvalidDecl() || alias->isInvalidDecl() ||
       alias->getUnderlyingType()->containsErrors() ||
       refersToUndeclared(ctx, alias->getUnderlyingType())) {
-    log() << "rule " << id->module << "::" << id->name << " does not apply\n";
+    log() << "rule " << id->dir << "::" << id->name << " does not apply\n";
     return;
   }
-  auto *rule = RuleRegistry::FindTypeRule(id->module, id->name);
+  auto *rule = RuleRegistry::FindTypeRule(id->dir, id->name);
   if (!rule) {
-    log() << "rule " << id->module << "::" << id->name << " has no target\n";
+    log() << "rule " << id->dir << "::" << id->name << " has no target\n";
     return;
   }
   if (!llvm::isa<clang::TypeAliasTemplateDecl>(decl)) {
-    log() << "rule " << id->module << "::" << id->name << " is a plain type\n";
+    log() << "rule " << id->dir << "::" << id->name << " is a plain type\n";
     auto add = [&](auto &types, auto key) {
       auto [it, inserted] = types.try_emplace(std::move(key), rule);
       if (!inserted && it->second != rule) {
@@ -443,13 +442,13 @@ void addTypeRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
   if (const auto *member =
           alias->getUnderlyingType()->getAs<clang::DependentNameType>()) {
     auto key = member->getIdentifier()->getName().str();
-    log() << "rule " << id->module << "::" << id->name << " -> member '" << key
+    log() << "rule " << id->dir << "::" << id->name << " -> member '" << key
           << "'\n";
     member_types_.emplace(std::move(key), TypeRuleDecl{decl, rule});
     return;
   }
   auto key = GetTypeKey(alias->getUnderlyingType());
-  log() << "rule " << id->module << "::" << id->name << " -> '" << key << "'\n";
+  log() << "rule " << id->dir << "::" << id->name << " -> '" << key << "'\n";
   types_.emplace(std::move(key), TypeRuleDecl{decl, rule});
 }
 
diff --git a/cpp2rust/rules_prelude.cpp b/cpp2rust/rules_prelude.cpp
index 371f6d0808..acf0daddc6 100644
--- a/cpp2rust/rules_prelude.cpp
+++ b/cpp2rust/rules_prelude.cpp
@@ -85,16 +85,16 @@ std::set<std::string> getRuleNames(const std::string &text) {
   return names;
 }
 
-void addCxxModule(std::string &out, const fs::path &module_dir) {
+void addCxxRules(std::string &out, const fs::path &rule_dir) {
   out += std::format("namespace cpp2rust_rules_{} {{\n",
-                     module_dir.filename().string());
-  out += withoutIncludes(readFile(module_dir / "src.cpp"));
-  out += withoutIncludes(readFile(module_dir / "src.c"));
+                     rule_dir.filename().string());
+  out += withoutIncludes(readFile(rule_dir / "src.cpp"));
+  out += withoutIncludes(readFile(rule_dir / "src.c"));
   out += "}\n";
 }
 
-void addCRules(std::string &out, const std::string &prefix,
-               const std::string &text) {
+void addPrefixedRules(std::string &out, const std::string &prefix,
+                      const std::string &text) {
   auto names = getRuleNames(text);
   for (const auto &name : names) {
     out += std::format("#define {} {}_{}\n", name, prefix, name);
@@ -105,9 +105,9 @@ void addCRules(std::string &out, const std::string &prefix,
   }
 }
 
-void addCModule(std::string &out, const fs::path &module_dir) {
-  auto prefix = "cpp2rust_rules_" + module_dir.filename().string();
-  addCRules(out, prefix, readFile(module_dir / "src.c"));
+void addCRules(std::string &out, const fs::path &rule_dir) {
+  auto prefix = "cpp2rust_rules_" + rule_dir.filename().string();
+  addPrefixedRules(out, prefix, readFile(rule_dir / "src.c"));
 }
 
 } // namespace
@@ -132,20 +132,20 @@ std::string GetRulesPreludeInclude(RulesLanguage language) {
 }
 
 std::string BuildRulesPrelude(RulesLanguage language) {
-  std::vector<fs::path> modules;
+  std::vector<fs::path> rule_dirs;
   for (const auto &entry : fs::directory_iterator(RULES_SOURCE_DIR)) {
     if (entry.is_directory()) {
-      modules.push_back(entry.path());
+      rule_dirs.push_back(entry.path());
     }
   }
-  std::sort(modules.begin(), modules.end());
+  std::sort(rule_dirs.begin(), rule_dirs.end());
 
   std::string out = "#pragma GCC system_header\n";
-  for (const auto &module_dir : modules) {
+  for (const auto &rule_dir : rule_dirs) {
     if (language == RulesLanguage::kCxx) {
-      addCxxModule(out, module_dir);
+      addCxxRules(out, rule_dir);
     } else {
-      addCModule(out, module_dir);
+      addCRules(out, rule_dir);
     }
   }
   return out;

From 9ad2c3b2b257aea12ad8f864a65ac072f37870e0 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sun, 4 Oct 2026 10:28:58 +0100
Subject: [PATCH 31/34] clang-format

---
 cpp2rust/converter/rules/rule_decls.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/cpp2rust/converter/rules/rule_decls.cpp b/cpp2rust/converter/rules/rule_decls.cpp
index 35bd09acb0..2ec340f9d7 100644
--- a/cpp2rust/converter/rules/rule_decls.cpp
+++ b/cpp2rust/converter/rules/rule_decls.cpp
@@ -353,8 +353,7 @@ void addExprRule(clang::ASTContext &ctx, const clang::NamedDecl *decl) {
       return;
     }
     auto key = GetExprKey(ctx, init);
-    log() << "rule " << id->dir << "::" << id->name << " -> '" << key
-          << "'\n";
+    log() << "rule " << id->dir << "::" << id->name << " -> '" << key << "'\n";
     exprs_.emplace(std::move(key), ExprRuleDecl{nullptr, init, rule, {}});
     return;
   }

From 8315809d9263391d5ab672358c9ac9fee3d733c1 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sun, 4 Oct 2026 12:20:57 +0100
Subject: [PATCH 32/34] Pass converter to mapper

---
 cpp2rust/ast_consumer.cpp                     |  1 -
 cpp2rust/converter/converter.cpp              | 43 ++++++++-----
 cpp2rust/converter/converter.h                |  6 ++
 cpp2rust/converter/converter_lib.cpp          | 20 ++++--
 cpp2rust/converter/converter_lib.h            |  2 +
 cpp2rust/converter/mapper.cpp                 | 33 ++++++----
 cpp2rust/converter/mapper.h                   | 14 ++--
 .../converter/models/converter_refcount.cpp   | 16 +++--
 .../converter/models/converter_refcount.h     |  2 +
 cpp2rust/converter/printer.cpp                |  3 +-
 cpp2rust/converter/rules/matcher.cpp          | 27 ++------
 cpp2rust/converter/rules/matcher.h            |  8 ++-
 cpp2rust/converter/rules/registry.cpp         | 64 ++++---------------
 cpp2rust/converter/rules/registry.h           |  5 --
 cpp2rust/converter/translation_rule.h         | 10 ---
 15 files changed, 119 insertions(+), 135 deletions(-)

diff --git a/cpp2rust/ast_consumer.cpp b/cpp2rust/ast_consumer.cpp
index 07e72ee9e4..86032b2751 100644
--- a/cpp2rust/ast_consumer.cpp
+++ b/cpp2rust/ast_consumer.cpp
@@ -12,7 +12,6 @@ namespace cpp2rust {
 void ASTConsumer::HandleTranslationUnit(clang::ASTContext &ctx) {
   auto converter = CreateConverter(rs_code_, ctx, model_, rules_dir_);
   RuleDecls::Collect(CI_.getSema());
-  RuleRegistry::ResetUserTypes();
   converter->SetSema(CI_.getSema());
   if (first_) {
     converter->EmitFilePreamble();
diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index f832673ffc..a06cd321bb 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -122,7 +122,7 @@ bool Converter::Convert(clang::QualType qual_type) {
     record_decls_.MarkReferenced(GetRecordName(decl));
   }
 
-  auto mapped = Mapper::Map(ctx_, qual_type);
+  auto mapped = Mapper::Map(*this, qual_type);
   if (!mapped.empty() && mapped != token::kIgnoreRule) {
     StrCat(mapped);
     return false;
@@ -132,8 +132,12 @@ bool Converter::Convert(clang::QualType qual_type) {
   return TraverseType(qual_type);
 }
 
+std::string Converter::GetUnboxedTypeAsString(clang::QualType qual_type) {
+  return ToString(qual_type);
+}
+
 bool Converter::ConvertMappedType(clang::QualType qual_type) {
-  std::string type_as_string = Mapper::Map(ctx_, qual_type);
+  std::string type_as_string = Mapper::Map(*this, qual_type);
   if (type_as_string == token::kIgnoreRule) {
     return false;
   }
@@ -155,7 +159,7 @@ std::string Converter::ConvertPointeeType(clang::QualType ptr_type) {
 }
 
 bool Converter::VisitBuiltinType(clang::BuiltinType *type) {
-  auto mapped = Mapper::Map(ctx_, clang::QualType(type, 0));
+  auto mapped = Mapper::Map(*this, clang::QualType(type, 0));
   if (mapped.empty()) {
     llvm::report_fatal_error(llvm::Twine("no type rule for builtin type: ") +
                              type->getName(ctx_.getPrintingPolicy()));
@@ -185,6 +189,11 @@ bool Converter::VisitRecordType(clang::RecordType *type) {
   return false;
 }
 
+bool Converter::VisitEnumType(clang::EnumType *type) {
+  StrCat(GetRecordName(type->getDecl()));
+  return false;
+}
+
 std::string
 Converter::ConvertPointer(clang::Expr *expr,
                           std::optional<clang::QualType> implicit_convert_to,
@@ -312,7 +321,7 @@ bool Converter::VisitPointerType(clang::PointerType *type) {
   auto pointee_type = type->getPointeeType();
   StrCat(pointee_type.isConstQualified() ? "*const" : "*mut");
   if (pointee_type->isRecordType() &&
-      abstract_structs_.contains(GetID(pointee_type->getAsRecordDecl()))) {
+      IsAbstractUserClass(pointee_type->getAsRecordDecl())) {
     StrCat(keyword::kDyn);
   }
   return Convert(pointee_type);
@@ -709,7 +718,7 @@ bool Converter::RecordHasCopyableFields(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
-    auto mapped = Mapper::Map(ctx_, f->getType());
+    auto mapped = Mapper::Map(*this, f->getType());
     if (mapped.starts_with("Vec<")) {
       return false;
     }
@@ -1490,7 +1499,7 @@ bool Converter::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
   auto loop_var_name = GetNamedDeclAsString(loop_var);
 
   StrCat("'loop_:");
-  auto map_type = Mapper::Map(ctx_, stmt->getRangeInit()->getType());
+  auto map_type = Mapper::Map(*this, stmt->getRangeInit()->getType());
   StrCat(keyword::kFor, loop_var_name, keyword::kIn,
          "UnsafeMapIterator::begin(&");
   Convert(stmt->getRangeInit());
@@ -1659,7 +1668,7 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
   } else if (IsStdSetw(arg)) {
     fmt_width = Trim(ToString(arg));
   } else if (!arg->getType()->isCharType() &&
-             Mapper::Map(ctx_, arg->getType()) !=
+             Mapper::Map(*this, arg->getType()) !=
                  std::format("Vec<{}>", CharRustType())) {
     fmt += ("{:" + fmt_width + fmt_trait + "}");
     fmt_width.clear(); // Reset setw after first usage
@@ -1677,7 +1686,7 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
 bool Converter::GetRawArg(clang::Expr *arg, std::string &raw_args) {
   if (arg->getType()->isCharType()) {
     raw_args += "(&[" + ToString(arg) + " as u8]";
-  } else if (Mapper::Map(ctx_, arg->getType()) ==
+  } else if (Mapper::Map(*this, arg->getType()) ==
              std::format("Vec<{}>", CharRustType())) {
     PushExprKind push(*this, ExprKind::RValue);
     std::string str = ToString(arg);
@@ -2127,7 +2136,7 @@ void Converter::EmitArgList(const CallInfo &info) {
         ConvertParamTy(ca.param_type, ca.expr);
         if (info.is_libc_passthrough) {
           StrCat(
-              std::format("as {}", Mapper::GetParamType(ctx_, info.expr, i)));
+              std::format("as {}", Mapper::GetParamType(*this, info.expr, i)));
         }
         break;
       }
@@ -2263,7 +2272,7 @@ std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
 
   if (ty->isFloatingType() || incl_type) {
     if (value.isZero()) {
-      if (auto init = Mapper::MapInitializer(ctx_, ty); !init.empty()) {
+      if (auto init = Mapper::MapInitializer(*this, ty); !init.empty()) {
         return init;
       }
     }
@@ -2279,7 +2288,7 @@ bool Converter::VisitIntegerLiteral(clang::IntegerLiteral *expr) {
     computed_expr_type_ = ComputedExprType::FreshValue;
     return false;
   }
-  StrCat(getIntegerLiteral(expr, Mapper::Map(ctx_, expr->getType()) != "i32"));
+  StrCat(getIntegerLiteral(expr, Mapper::Map(*this, expr->getType()) != "i32"));
   computed_expr_type_ = ComputedExprType::FreshValue;
   return false;
 }
@@ -4046,7 +4055,7 @@ std::string Converter::GetDefaultAsString(clang::QualType qual_type) {
     return arr;
   }
 
-  if (auto init = Mapper::MapInitializer(ctx_, qual_type); !init.empty()) {
+  if (auto init = Mapper::MapInitializer(*this, qual_type); !init.empty()) {
     computed_expr_type_ = ComputedExprType::FreshValue;
     return init;
   }
@@ -4239,7 +4248,7 @@ void Converter::ConvertUnsignedArithOperand(clang::Expr *expr,
   bool needs_cast =
       (expr->isIntegerConstantExpr(ctx_) &&
        !clang::isa<clang::ImplicitCastExpr>(expr)) ||
-      Mapper::Map(ctx_, expr->getType()) != Mapper::Map(ctx_, type);
+      Mapper::Map(*this, expr->getType()) != Mapper::Map(*this, type);
   PushParen paren(*this, needs_cast);
   Convert(expr);
   if (needs_cast) {
@@ -4339,7 +4348,7 @@ void Converter::ConvertArraySubscript(clang::Expr *base, clang::Expr *idx,
     Convert(idx);
   }
 
-  if (Mapper::Map(ctx_, idx->getType()) != "usize") {
+  if (Mapper::Map(*this, idx->getType()) != "usize") {
     StrCat(keyword::kAs, "usize");
   }
 }
@@ -4884,7 +4893,7 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
 
   if (ph_ctx.declared_in_rule_as_rust_ptr && arg->getType()->isArrayType()) {
     return std::format("({} as {})", ConvertFreshPointer(arg),
-                       Mapper::GetParamType(ctx_, expr, ph_ctx.arg_idx));
+                       Mapper::GetParamType(*this, expr, ph_ctx.arg_idx));
   }
 
   if (ph_ctx.needs_materialization()) {
@@ -4899,7 +4908,7 @@ std::string Converter::ConvertPlaceholder(clang::Expr *expr, clang::Expr *arg,
   }
 
   if (ph_ctx.needs_pointer_receiver()) {
-    auto param_type = Mapper::GetParamType(ctx_, expr, ph_ctx.arg_idx);
+    auto param_type = Mapper::GetParamType(*this, expr, ph_ctx.arg_idx);
     return std::format("({} as {})", ConvertFreshObject(arg, param_type),
                        param_type);
   }
@@ -4989,7 +4998,7 @@ std::string Converter::ConvertIRFragment(
     if (auto *t = std::get_if<TextFragment>(&frag)) {
       result += t->text;
     } else if (auto *g = std::get_if<GenericFragment>(&frag)) {
-      result += Mapper::InstantiateTemplate(ctx_, expr, g->n);
+      result += Mapper::InstantiateTemplate(*this, expr, g->n);
     } else if (auto *ph = std::get_if<PlaceholderFragment>(&frag)) {
       auto arg_idx = ph->n;
       assert(arg_idx < all_args.size());
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index e2591f2ff1..7f84b94400 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -48,6 +48,10 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     return *sema_;
   }
 
+  clang::ASTContext &GetASTContext() { return ctx_; }
+
+  virtual std::string GetUnboxedTypeAsString(clang::QualType qual_type);
+
   bool VisitRecoveryExpr(clang::RecoveryExpr *expr);
 
   virtual void EmitFilePreamble();
@@ -61,6 +65,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitRecordType(clang::RecordType *type);
 
+  bool VisitEnumType(clang::EnumType *type);
+
   virtual bool VisitConstantArrayType(clang::ConstantArrayType *type);
 
   virtual bool VisitIncompleteArrayType(clang::IncompleteArrayType *type);
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index 90e8d28d8a..fdf2edec3c 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -231,6 +231,13 @@ bool IsUserDefinedDecl(const clang::Decl *decl) {
          !src_mgr.isInSystemMacro(src_loc);
 }
 
+bool IsAbstractUserClass(const clang::RecordDecl *decl) {
+  auto *cxx = llvm::dyn_cast<clang::CXXRecordDecl>(decl);
+  auto *definition = cxx ? cxx->getDefinition() : nullptr;
+  return definition && IsUserDefinedDecl(definition) &&
+         definition->isAbstract();
+}
+
 bool RefersToUserDefinedDecl(const clang::Expr *expr) {
   expr = expr->IgnoreParenImpCasts();
   const clang::Decl *decl = nullptr;
@@ -1490,13 +1497,10 @@ std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
 std::optional<IteratorCategory>
 GetStrongestIteratorCategory(clang::ASTContext &ctx, clang::QualType type) {
   type = type.getNonReferenceType().getUnqualifiedType();
-  if (!Mapper::Contains(ctx, type)) {
-    return std::nullopt;
-  }
   if (RuleRegistry::MapsToRefcountPointer(ctx, type)) {
     return IteratorCategory::Contiguous;
   }
-  auto mapped = Mapper::Map(ctx, type);
+  auto mapped = Mapper::MapUninstantiated(ctx, type);
   if (mapped.empty()) {
     return std::nullopt;
   }
@@ -1579,7 +1583,8 @@ bool NeedsImplicitScalarCast(clang::ASTContext &ctx, clang::QualType from,
          to->isIntegerType() &&
          from.getCanonicalType().getUnqualifiedType() ==
              to.getCanonicalType().getUnqualifiedType() &&
-         Mapper::Map(ctx, from) != Mapper::Map(ctx, to);
+         Mapper::MapUninstantiated(ctx, from) !=
+             Mapper::MapUninstantiated(ctx, to);
 }
 
 clang::QualType GetExprPointee(clang::ASTContext &ctx, const clang::Expr *from,
@@ -1633,7 +1638,8 @@ static bool PointeeMappingDiffers(clang::ASTContext &ctx, clang::QualType from,
   }
   return from.getCanonicalType().getUnqualifiedType() ==
              to.getCanonicalType().getUnqualifiedType() &&
-         Mapper::Map(ctx, from) != Mapper::Map(ctx, to);
+         Mapper::MapUninstantiated(ctx, from) !=
+             Mapper::MapUninstantiated(ctx, to);
 }
 
 bool NeedsImplicitPointeeCast(clang::ASTContext &ctx, const clang::Expr *from,
@@ -1672,7 +1678,7 @@ bool NeedsRefBindingTemp(clang::ASTContext &ctx, const clang::Expr *arg,
 }
 
 bool IsSizeType(clang::ASTContext &ctx, clang::QualType type) {
-  auto rust_type = Mapper::Map(ctx, type);
+  auto rust_type = Mapper::MapUninstantiated(ctx, type);
   return rust_type == "usize" || rust_type == "isize";
 }
 
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index fa4986f81d..c22c08a308 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -62,6 +62,8 @@ bool IsCodeUnitStringLiteral(const clang::StringLiteral *expr);
 
 bool IsUserDefinedDecl(const clang::Decl *decl);
 
+bool IsAbstractUserClass(const clang::RecordDecl *decl);
+
 bool RefersToUserDefinedDecl(const clang::Expr *expr);
 
 bool IsUnsignedArithOp(const clang::BinaryOperator *expr);
diff --git a/cpp2rust/converter/mapper.cpp b/cpp2rust/converter/mapper.cpp
index 4b8189531d..add47a3b2d 100644
--- a/cpp2rust/converter/mapper.cpp
+++ b/cpp2rust/converter/mapper.cpp
@@ -11,6 +11,7 @@
 #include <utility>
 #include <vector>
 
+#include "converter/converter.h"
 #include "converter/converter_lib.h"
 #include "converter/rules/matcher.h"
 #include "converter/rules/registry.h"
@@ -38,36 +39,44 @@ std::string MapFunctionName(clang::ASTContext &ctx,
   return GetNamedDeclAsString(decl->getCanonicalDecl());
 }
 
-std::string InstantiateTemplate(clang::ASTContext &ctx, const clang::Expr *expr,
+std::string InstantiateTemplate(Converter &converter, const clang::Expr *expr,
                                 unsigned n) {
-  auto [rule, subs] = RuleRegistry::Search(ctx, expr);
+  auto [rule, subs] = RuleRegistry::Search(converter.GetASTContext(), expr);
   auto text = std::format("T{}", n);
   if (!rule) {
     return text;
   }
-  return Matcher::MapBinding(ctx, subs, n - 1);
+  return Matcher::MapBinding(converter, subs, n - 1);
 }
 
-std::string Map(clang::ASTContext &ctx, clang::QualType qual_type) {
-  auto [rule, subs] = RuleRegistry::Search(ctx, qual_type);
+std::string Map(Converter &converter, clang::QualType qual_type) {
+  auto [rule, subs] =
+      RuleRegistry::Search(converter.GetASTContext(), qual_type);
   if (rule) {
-    return Matcher::InstantiateTgt(ctx, subs, rule->type_info.type);
+    return Matcher::InstantiateTgt(converter, subs, rule->type_info.type);
   }
   return {};
 }
 
-std::string MapInitializer(clang::ASTContext &ctx, clang::QualType qual_type) {
-  auto [rule, subs] = RuleRegistry::Search(ctx, qual_type);
+std::string MapUninstantiated(clang::ASTContext &ctx,
+                              clang::QualType qual_type) {
+  auto rule = RuleRegistry::Search(ctx, qual_type).first;
+  return rule ? rule->type_info.type : std::string();
+}
+
+std::string MapInitializer(Converter &converter, clang::QualType qual_type) {
+  auto [rule, subs] =
+      RuleRegistry::Search(converter.GetASTContext(), qual_type);
   if (rule && !rule->initializer.empty()) {
-    return Matcher::InstantiateTgt(ctx, subs, rule->initializer);
+    return Matcher::InstantiateTgt(converter, subs, rule->initializer);
   }
   return {};
 }
 
-std::string GetParamType(clang::ASTContext &ctx, const clang::Expr *expr,
+std::string GetParamType(Converter &converter, const clang::Expr *expr,
                          unsigned index) {
-  auto [rule, subs] = RuleRegistry::Search(ctx, expr);
-  return Matcher::InstantiateTgt(ctx, subs, rule->params.at(index).type);
+  auto [rule, subs] = RuleRegistry::Search(converter.GetASTContext(), expr);
+  return Matcher::InstantiateTgt(converter, subs, rule->params.at(index).type);
 }
 
 } // namespace cpp2rust::Mapper
diff --git a/cpp2rust/converter/mapper.h b/cpp2rust/converter/mapper.h
index 8d4838492d..6a2dbce4c6 100644
--- a/cpp2rust/converter/mapper.h
+++ b/cpp2rust/converter/mapper.h
@@ -11,16 +11,22 @@
 
 #include "converter/translation_rule.h"
 
+namespace cpp2rust {
+class Converter;
+}
+
 namespace cpp2rust::Mapper {
 bool Contains(clang::ASTContext &ctx, clang::QualType qual_type);
 bool Contains(clang::ASTContext &ctx, const clang::Expr *expr);
 
-std::string Map(clang::ASTContext &ctx, clang::QualType qual_type);
-std::string MapInitializer(clang::ASTContext &ctx, clang::QualType qual_type);
+std::string Map(Converter &converter, clang::QualType qual_type);
+std::string MapUninstantiated(clang::ASTContext &ctx,
+                              clang::QualType qual_type);
+std::string MapInitializer(Converter &converter, clang::QualType qual_type);
 std::string MapFunctionName(clang::ASTContext &ctx,
                             const clang::FunctionDecl *decl);
-std::string InstantiateTemplate(clang::ASTContext &ctx, const clang::Expr *expr,
+std::string InstantiateTemplate(Converter &converter, const clang::Expr *expr,
                                 unsigned n);
-std::string GetParamType(clang::ASTContext &ctx, const clang::Expr *expr,
+std::string GetParamType(Converter &converter, const clang::Expr *expr,
                          unsigned index);
 } // namespace cpp2rust::Mapper
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 040d4ce605..c1a5710d24 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -52,7 +52,7 @@ static bool IsBoxedType(std::string_view type) {
 }
 
 static bool IsBoxedType(clang::ASTContext &ctx, clang::QualType type) {
-  return IsBoxedType(Mapper::Map(ctx, type.getUnqualifiedType()));
+  return IsBoxedType(Mapper::MapUninstantiated(ctx, type.getUnqualifiedType()));
 }
 
 // Virtual methods take &mut self, as the fields of the struct are stored in
@@ -196,6 +196,12 @@ std::string ConverterRefCount::BoxValue(std::string &&str) const {
   std::unreachable();
 }
 
+std::string
+ConverterRefCount::GetUnboxedTypeAsString(clang::QualType qual_type) {
+  PushConversionKind push(*this, ConversionKind::Unboxed);
+  return ToString(qual_type);
+}
+
 bool ConverterRefCount::Convert(clang::QualType qual_type) {
   // Catch va_list before desugaring
   if (IsVaListType(qual_type)) {
@@ -276,7 +282,7 @@ bool ConverterRefCount::VisitPointerType(clang::PointerType *type) {
   PushConversionKind push2(*this, ConversionKind::FullRefCount,
                            pointee_type->isArrayType());
   if (pointee_type->isRecordType() &&
-      abstract_structs_.contains(GetID(pointee_type->getAsRecordDecl()))) {
+      IsAbstractUserClass(pointee_type->getAsRecordDecl())) {
     StrCat("PtrDyn<dyn");
   } else {
     StrCat("Ptr<");
@@ -2011,7 +2017,7 @@ bool ConverterRefCount::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
 
   EmitByValueShadow(
       loop_var_name, loop_var->getType(), std::string(loop_var_name),
-      "Value<" + Mapper::Map(ctx_, GetForRangeIteratorType(stmt)) + '>');
+      "Value<" + Mapper::Map(*this, GetForRangeIteratorType(stmt)) + '>');
 
   ConvertForRangeBody(stmt, loop_var);
 
@@ -2241,7 +2247,7 @@ std::string ConverterRefCount::GetDefaultAsString(clang::QualType qual_type) {
     return BoxValue(std::move(arr));
   }
 
-  if (auto init = Mapper::MapInitializer(ctx_, qual_type); !init.empty()) {
+  if (auto init = Mapper::MapInitializer(*this, qual_type); !init.empty()) {
     computed_expr_type_ = ComputedExprType::FreshValue;
     return BoxValue(std::move(init));
   }
@@ -2957,7 +2963,7 @@ std::string ConverterRefCount::ConvertMappedMethodCall(
     arg = call->getArg(0);
   }
 
-  auto param_type = Mapper::GetParamType(ctx_, expr, arg_idx);
+  auto param_type = Mapper::GetParamType(*this, expr, arg_idx);
 
   if (arg->getType()->isPointerType()) {
     return std::format("{}.with_mut(|__v: {}| __v{})", ConvertPointer(arg),
diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h
index 58cb4673a7..6a5000a0e3 100644
--- a/cpp2rust/converter/models/converter_refcount.h
+++ b/cpp2rust/converter/models/converter_refcount.h
@@ -12,6 +12,8 @@ class ConverterRefCount final : public Converter {
 
   void EmitFilePreamble() override;
 
+  std::string GetUnboxedTypeAsString(clang::QualType qual_type) override;
+
   static void EmitMethodsOnPtr(std::string &out);
 
   bool VisitRecordType(clang::RecordType *type) override;
diff --git a/cpp2rust/converter/printer.cpp b/cpp2rust/converter/printer.cpp
index 1e889eca68..481993fa57 100644
--- a/cpp2rust/converter/printer.cpp
+++ b/cpp2rust/converter/printer.cpp
@@ -151,7 +151,8 @@ std::string ToString(clang::ASTContext &ctx, clang::QualType qual_type,
                            ToString(ctx, pointee.getUnqualifiedType(),
                                     ScalarSugar::kPreserve));
       }
-      if (Mapper::Map(ctx, pointee) == Mapper::Map(ctx, canonical)) {
+      if (Mapper::MapUninstantiated(ctx, pointee) ==
+          Mapper::MapUninstantiated(ctx, canonical)) {
         pointee = canonical;
       }
       std::string out;
diff --git a/cpp2rust/converter/rules/matcher.cpp b/cpp2rust/converter/rules/matcher.cpp
index 402890cef6..fb0b2b9b82 100644
--- a/cpp2rust/converter/rules/matcher.cpp
+++ b/cpp2rust/converter/rules/matcher.cpp
@@ -17,6 +17,7 @@
 #include <cctype>
 #include <vector>
 
+#include "converter/converter.h"
 #include "converter/converter_lib.h"
 #include "converter/mapper.h"
 #include "converter/printer.h"
@@ -567,16 +568,6 @@ TypeMatch findLoadedType(clang::ASTContext &ctx, clang::QualType type) {
   return {best, std::move(best_bindings)};
 }
 
-TypeMatch findType(clang::ASTContext &ctx, clang::QualType type) {
-  auto match = findLoadedType(ctx, type);
-  if (!match.first) {
-    if (auto *rule = RuleRegistry::FindUserType(ctx, type)) {
-      return {rule, {}};
-    }
-  }
-  return match;
-}
-
 } // namespace
 
 clang::QualType GetInitType(clang::ASTContext &ctx, const clang::Expr *expr) {
@@ -596,7 +587,7 @@ TranslationRule::TypeRule *FindLoaded(clang::ASTContext &ctx,
 }
 
 TypeMatch Find(clang::ASTContext &ctx, clang::QualType type) {
-  auto match = findType(ctx, type);
+  auto match = findLoadedType(ctx, type);
   log() << "search type " << Printer::ToString(ctx, type)
         << ", result: " << (match.first ? match.first->type_info.type : "None")
         << '\n';
@@ -608,23 +599,18 @@ bool HasRuleNamed(const clang::FunctionDecl *decl) {
          !RuleDecls::ExprCandidates(decl->getName().str()).empty();
 }
 
-std::string MapBinding(clang::ASTContext &ctx, const Bindings &bindings,
+std::string MapBinding(Converter &converter, const Bindings &bindings,
                        unsigned n) {
   auto type = bindings.at(n);
   assert(!type.isNull() && "template parameter is not bound to a type");
-  auto mapped = Mapper::Map(ctx, type);
-  if (mapped.empty()) {
-    llvm::errs() << "cpp_type: " << Printer::ToString(ctx, type) << '\n';
-    assert(0 && "Type is not present in the registry");
-  }
-  return mapped;
+  return converter.GetUnboxedTypeAsString(type);
 }
 
 //
 // Example:
 //   tgt_template = "Vec<T1>"
 //   result       = "Vec<i32>"
-std::string InstantiateTgt(clang::ASTContext &ctx, const Bindings &types,
+std::string InstantiateTgt(Converter &converter, const Bindings &types,
                            const std::string &tgt_template) {
   assert(types.size() <= TranslationRule::kMaxGenerics &&
          "template placeholder exceeds kMaxGenerics");
@@ -638,7 +624,8 @@ std::string InstantiateTgt(clang::ASTContext &ctx, const Bindings &types,
       ++pos;
       continue;
     }
-    auto repl = MapBinding(ctx, types, instantiated_template[pos + 1] - '1');
+    auto repl =
+        MapBinding(converter, types, instantiated_template[pos + 1] - '1');
     instantiated_template.replace(pos, 2, repl);
     pos += repl.length();
   }
diff --git a/cpp2rust/converter/rules/matcher.h b/cpp2rust/converter/rules/matcher.h
index f471bbfe96..ee1c778d93 100644
--- a/cpp2rust/converter/rules/matcher.h
+++ b/cpp2rust/converter/rules/matcher.h
@@ -14,6 +14,10 @@
 
 #include "converter/translation_rule.h"
 
+namespace cpp2rust {
+class Converter;
+}
+
 namespace cpp2rust::Matcher {
 using Bindings = std::vector<clang::QualType>;
 
@@ -31,9 +35,9 @@ clang::QualType GetInitType(clang::ASTContext &ctx, const clang::Expr *expr);
 
 bool HasRuleNamed(const clang::FunctionDecl *decl);
 
-std::string MapBinding(clang::ASTContext &ctx, const Bindings &bindings,
+std::string MapBinding(Converter &converter, const Bindings &bindings,
                        unsigned n);
 
-std::string InstantiateTgt(clang::ASTContext &ctx, const Bindings &types,
+std::string InstantiateTgt(Converter &converter, const Bindings &types,
                            const std::string &tgt_template);
 } // namespace cpp2rust::Matcher
diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp
index d667158b3e..0dc433b168 100644
--- a/cpp2rust/converter/rules/registry.cpp
+++ b/cpp2rust/converter/rules/registry.cpp
@@ -23,19 +23,12 @@ bool translation_rules_loaded_ = false;
 std::unordered_map<std::string, TranslationRule::ExprRule> exprs_;
 std::unordered_map<std::string, TranslationRule::TypeRule> types_;
 
-std::unordered_map<const void *, TranslationRule::TypeRule> user_types_;
-
-TranslationRule::TypeRule userPointerRule(const std::string &rs_name,
-                                          bool abstract) {
-  switch (model_) {
-  case Model::kUnsafe:
-    return TranslationRule::TypeRule::UnsafePtr(
-        (abstract ? "*mut dyn " : "*mut ") + rs_name);
-  case Model::kRefCount:
-    return TranslationRule::TypeRule::RefcountPtr(
-        (abstract ? "PtrDyn<dyn " : "Ptr<") + rs_name + '>');
+bool pointsToUserType(clang::QualType type) {
+  if (!type->isPointerType()) {
+    return false;
   }
-  __builtin_unreachable();
+  auto *tag = type->getPointeeType()->getAsTagDecl();
+  return tag && IsUserDefinedDecl(tag);
 }
 
 void addRulesFromDirectory(const std::filesystem::path &dir, Model model) {
@@ -80,43 +73,6 @@ TranslationRule::TypeRule *FindTypeRule(const std::string &dir,
   return it == types_.end() ? nullptr : &it->second;
 }
 
-TranslationRule::TypeRule *FindUserType(clang::ASTContext &ctx,
-                                        clang::QualType type) {
-  type = type.getCanonicalType().getUnqualifiedType();
-  auto it = user_types_.find(type.getAsOpaquePtr());
-  if (it != user_types_.end()) {
-    return &it->second;
-  }
-  bool pointer = type->isPointerType();
-  auto tag_type = pointer ? type->getPointeeType() : type;
-  if (tag_type.hasQualifiers()) {
-    return nullptr;
-  }
-  auto *tag = tag_type->getAsTagDecl();
-  if (!tag || !IsUserDefinedDecl(tag)) {
-    return nullptr;
-  }
-  auto rs_name =
-      Printer::ToRustName(Printer::ToString(ctx, GetTypeForDecl(ctx, tag)));
-  if (!pointer) {
-    return &user_types_
-                .emplace(type.getAsOpaquePtr(),
-                         TranslationRule::TypeRule::Plain(rs_name))
-                .first->second;
-  }
-  auto *cxx = llvm::dyn_cast<clang::CXXRecordDecl>(tag);
-  auto *definition = cxx ? cxx->getDefinition() : nullptr;
-  if (!definition) {
-    return nullptr;
-  }
-  return &user_types_
-              .emplace(type.getAsOpaquePtr(),
-                       userPointerRule(rs_name, definition->isAbstract()))
-              .first->second;
-}
-
-void ResetUserTypes() { user_types_.clear(); }
-
 Matcher::Match<TranslationRule::ExprRule> Search(clang::ASTContext &ctx,
                                                  const clang::Expr *expr) {
   if (RefersToUserDefinedDecl(expr)) {
@@ -137,12 +93,18 @@ const TranslationRule::ExprRule *GetExprRule(clang::ASTContext &ctx,
 
 bool MapsToPointer(clang::ASTContext &ctx, clang::QualType qual_type) {
   auto rule = Search(ctx, qual_type).first;
-  return rule && rule->type_info.is_pointer();
+  if (!rule) {
+    return pointsToUserType(qual_type);
+  }
+  return rule->type_info.is_pointer();
 }
 
 bool MapsToRefcountPointer(clang::ASTContext &ctx, clang::QualType qual_type) {
   auto rule = Search(ctx, qual_type).first;
-  return rule && rule->type_info.is_refcount_pointer;
+  if (!rule) {
+    return model_ == Model::kRefCount && pointsToUserType(qual_type);
+  }
+  return rule->type_info.is_refcount_pointer;
 }
 
 bool ReturnsPointer(clang::ASTContext &ctx, const clang::Expr *expr) {
diff --git a/cpp2rust/converter/rules/registry.h b/cpp2rust/converter/rules/registry.h
index 3412303988..b2884f0a17 100644
--- a/cpp2rust/converter/rules/registry.h
+++ b/cpp2rust/converter/rules/registry.h
@@ -24,11 +24,6 @@ TranslationRule::ExprRule *FindExprRule(const std::string &dir,
 TranslationRule::TypeRule *FindTypeRule(const std::string &dir,
                                         const std::string &name);
 
-TranslationRule::TypeRule *FindUserType(clang::ASTContext &ctx,
-                                        clang::QualType type);
-
-void ResetUserTypes();
-
 Matcher::Match<TranslationRule::ExprRule> Search(clang::ASTContext &ctx,
                                                  const clang::Expr *expr);
 Matcher::Match<TranslationRule::TypeRule> Search(clang::ASTContext &ctx,
diff --git a/cpp2rust/converter/translation_rule.h b/cpp2rust/converter/translation_rule.h
index 27b9b1c9e9..07fbf49774 100644
--- a/cpp2rust/converter/translation_rule.h
+++ b/cpp2rust/converter/translation_rule.h
@@ -89,16 +89,6 @@ struct TypeRule {
   TypeInfo type_info;
 
   void dump() const;
-
-  static TypeRule Plain(std::string type) {
-    return {{}, {{}, std::move(type), false, false}};
-  }
-  static TypeRule RefcountPtr(std::string type) {
-    return {{}, {{}, std::move(type), true, false}};
-  }
-  static TypeRule UnsafePtr(std::string type) {
-    return {{}, {{}, std::move(type), false, true}};
-  }
 };
 
 using ExprRules = std::unordered_map<std::string, ExprRule>;

From 8d813b6c4e38444be7f81e42cd164932bb42d550 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sun, 4 Oct 2026 12:25:40 +0100
Subject: [PATCH 33/34] Add double const pointer test

---
 tests/unit/out/refcount/vector.rs | 29 +++++++++++++++++++++++++++++
 tests/unit/out/unsafe/vector.rs   | 21 +++++++++++++++++++++
 tests/unit/vector.cpp             | 16 ++++++++++++++++
 3 files changed, 66 insertions(+)

diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs
index 991a2e96a8..73e9dc1d35 100644
--- a/tests/unit/out/refcount/vector.rs
+++ b/tests/unit/out/refcount/vector.rs
@@ -6,6 +6,12 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
+#[derive(Clone, Record, ByteRepr, VaArg, FnPtrArg, Default)]
+#[byte_size(4)]
+pub struct S {
+    #[offset(0)]
+    pub x: i32,
+}
 pub fn copy_0(copy_vector: Vec<i32>) {
     let copy_vector: Value<Vec<i32>> = Rc::new(RefCell::new(copy_vector));
 }
@@ -250,6 +256,29 @@ fn main_0() -> i32 {
                 .read()) as usize)
         ) == 103_usize)
     );
+    let a: Value<S> = Rc::new(RefCell::new(S { x: 1 }));
+    let pa: Value<Ptr<S>> = Rc::new(RefCell::new((a.as_pointer())));
+    let v8: Value<Vec<Ptr<Ptr<S>>>> = Rc::new(RefCell::new(Vec::new()));
+    {
+        let __a1 = (pa.as_pointer());
+        (*v8.borrow_mut()).push(__a1)
+    };
+    assert!(
+        (((elem!((v8.as_pointer() as Ptr<Ptr<Ptr<S>>>), 0_usize).read()).read()).with(|__s| __s.x)
+            == 1)
+    );
+    let ppa: Value<Ptr<Ptr<S>>> = Rc::new(RefCell::new((pa.as_pointer())));
+    let v9: Value<Vec<Ptr<Ptr<Ptr<S>>>>> = Rc::new(RefCell::new(Vec::new()));
+    {
+        let __a1 = (ppa.as_pointer());
+        (*v9.borrow_mut()).push(__a1)
+    };
+    field!(
+        (((elem!((v9.as_pointer() as Ptr<Ptr<Ptr<Ptr<S>>>>), 0_usize).read()).read()).read()),
+        x
+    )
+    .write(2);
+    assert!(({ (*a.borrow()).x } == 2));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs
index b4f7f42500..aa45abc91c 100644
--- a/tests/unit/out/unsafe/vector.rs
+++ b/tests/unit/out/unsafe/vector.rs
@@ -6,6 +6,11 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
+#[repr(C)]
+#[derive(Copy, Clone, VaArg, Default)]
+pub struct S {
+    pub x: i32,
+}
 pub unsafe fn copy_0(mut copy_vector: Vec<i32>) {}
 pub fn main() {
     unsafe {
@@ -176,6 +181,22 @@ unsafe fn main_0() -> i32 {
             .wrapping_add(((*(&mut (v2)[0_usize as usize] as *mut i32)) as usize)))
             == (103_usize))
     );
+    let mut a: S = S { x: 1 };
+    let mut pa: *mut S = (&mut a as *mut S);
+    let mut v8: Vec<*const *mut S> = Vec::new();
+    {
+        let __a1 = (&mut pa as *mut *mut S).cast_const();
+        v8.push(__a1)
+    };
+    assert!((((*(*v8[(0_usize)])).x) == (1)));
+    let mut ppa: *mut *mut S = (&mut pa as *mut *mut S);
+    let mut v9: Vec<*mut *mut *mut S> = Vec::new();
+    {
+        let __a1 = (&mut ppa as *mut *mut *mut S);
+        v9.push(__a1)
+    };
+    (*(*(*v9[(0_usize)]))).x = 2;
+    assert!(((a.x) == (2)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/vector.cpp b/tests/unit/vector.cpp
index 4425eee294..b908ae949e 100644
--- a/tests/unit/vector.cpp
+++ b/tests/unit/vector.cpp
@@ -1,6 +1,10 @@
 #include <assert.h>
 #include <vector>
 
+struct S {
+  int x;
+};
+
 void copy(std::vector<int> copy_vector) {}
 
 int main() {
@@ -107,5 +111,17 @@ int main() {
   x1 -= 1.5;
   assert(v6.at(s2 - 1) == 6.5);
   assert(s1 + s2 + v2.at(0) == 103);
+
+  S a{1};
+  S *pa = &a;
+  std::vector<S *const *> v8;
+  v8.push_back(&pa);
+  assert((*v8[0])->x == 1);
+
+  S **ppa = &pa;
+  std::vector<S ***> v9;
+  v9.push_back(&ppa);
+  (**v9[0])->x = 2;
+  assert(a.x == 2);
   return 0;
 }

From 1d900a021b6d8f91edee9000e85359380baa40eb Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Sun, 4 Oct 2026 12:46:07 +0100
Subject: [PATCH 34/34] Delete find for user defined types in mapper

---
 cpp2rust/converter/converter.cpp     | 5 +++--
 cpp2rust/converter/rules/matcher.cpp | 9 ++-------
 cpp2rust/converter/rules/matcher.h   | 2 --
 3 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index a06cd321bb..0d83ac1dbe 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -697,7 +697,8 @@ bool Converter::IsPassThroughRule(clang::Expr *expr) const {
 }
 
 bool Converter::RecordDerivesCopy(const clang::RecordDecl *decl) {
-  if (auto *rule = Matcher::FindLoaded(ctx_, ctx_.getCanonicalTagType(decl))) {
+  if (auto *rule =
+          RuleRegistry::Search(ctx_, ctx_.getCanonicalTagType(decl)).first) {
     auto &derives = rule->type_info.derives;
     return std::find(derives.begin(), derives.end(), "Copy") != derives.end();
   }
@@ -3791,7 +3792,7 @@ bool Converter::VisitOffsetOfExpr(clang::OffsetOfExpr *expr) {
 
 bool Converter::VisitEnumDecl(clang::EnumDecl *decl) {
   ENSURE(decl_ids_.insert(GetID(decl)).second);
-  if (Matcher::FindLoaded(ctx_, ctx_.getCanonicalTagType(decl))) {
+  if (Mapper::Contains(ctx_, ctx_.getCanonicalTagType(decl))) {
     return false;
   }
   auto name = GetRecordName(decl);
diff --git a/cpp2rust/converter/rules/matcher.cpp b/cpp2rust/converter/rules/matcher.cpp
index fb0b2b9b82..4bf0450e5e 100644
--- a/cpp2rust/converter/rules/matcher.cpp
+++ b/cpp2rust/converter/rules/matcher.cpp
@@ -496,7 +496,7 @@ TypeMatch findMemberType(clang::ASTContext &ctx, clang::QualType type) {
   return {};
 }
 
-TypeMatch findLoadedType(clang::ASTContext &ctx, clang::QualType type) {
+TypeMatch findType(clang::ASTContext &ctx, clang::QualType type) {
   if (auto match = findMemberType(ctx, type); match.first) {
     return match;
   }
@@ -581,13 +581,8 @@ ExprMatch Find(clang::ASTContext &ctx, const clang::Expr *expr) {
   return findExpr(ctx, expr, nullptr);
 }
 
-TranslationRule::TypeRule *FindLoaded(clang::ASTContext &ctx,
-                                      clang::QualType type) {
-  return findLoadedType(ctx, type).first;
-}
-
 TypeMatch Find(clang::ASTContext &ctx, clang::QualType type) {
-  auto match = findLoadedType(ctx, type);
+  auto match = findType(ctx, type);
   log() << "search type " << Printer::ToString(ctx, type)
         << ", result: " << (match.first ? match.first->type_info.type : "None")
         << '\n';
diff --git a/cpp2rust/converter/rules/matcher.h b/cpp2rust/converter/rules/matcher.h
index ee1c778d93..81175613bc 100644
--- a/cpp2rust/converter/rules/matcher.h
+++ b/cpp2rust/converter/rules/matcher.h
@@ -25,8 +25,6 @@ template <typename Rule> using Match = std::pair<Rule *, Bindings>;
 
 Match<TranslationRule::ExprRule> Find(clang::ASTContext &ctx,
                                       const clang::Expr *expr);
-TranslationRule::TypeRule *FindLoaded(clang::ASTContext &ctx,
-                                      clang::QualType type);
 
 Match<TranslationRule::TypeRule> Find(clang::ASTContext &ctx,
                                       clang::QualType type);