Use same ASTNameGenerator for the duratoin of the Converter

Author: lucic71

cpp2rust/converter/converter.h

@@ -4,11 +4,13 @@
 // Distributed under the MIT license that can be found in the LICENSE file.
 
 #include <clang/AST/ASTContext.h>
+#include <clang/AST/Mangle.h>
 #include <clang/AST/RecursiveASTVisitor.h>
 #include <clang/Sema/Sema.h>
 
 #include <functional>
 #include <map>
+#include <memory>
 #include <optional>
 #include <string>
 #include <type_traits>
@@ -32,9 +34,18 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                      const char *keyword_unsafe = "unsafe",
                      const char *keyword_mut = keyword::kMut)
       : rs_code_(&rs_code), ctx_(ctx), keyword_unsafe_(keyword_unsafe),
-        keyword_mut_(keyword_mut) {}
+        keyword_mut_(keyword_mut) {
+    if (!GetNameGenerator()) {
+      name_generator_ = std::make_unique<clang::ASTNameGenerator>(ctx);
+      SetNameGenerator(name_generator_.get());
+    }
+  }
 
-  virtual ~Converter() = default;
+  virtual ~Converter() {
+    if (name_generator_) {
+      SetNameGenerator(nullptr);
+    }
+  }
 
   Converter(const Converter &) = delete;
   Converter &operator=(const Converter &) = delete;
@@ -784,6 +795,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   std::string *rs_code_;
   clang::ASTContext &ctx_;
+  std::unique_ptr<clang::ASTNameGenerator> name_generator_;
   clang::FunctionDecl *curr_function_ = nullptr;
   bool in_function_formals_ = false;
   enum class MethodTarget : uint8_t {

cpp2rust/converter/converter_lib.cpp

@@ -840,12 +840,25 @@ static std::string GetParamSignature(const clang::Decl *decl) {
   return args;
 }
 
+static clang::ASTNameGenerator *name_generator = nullptr;
+
+void SetNameGenerator(clang::ASTNameGenerator *generator) {
+  name_generator = generator;
+}
+
+clang::ASTNameGenerator *GetNameGenerator() { return name_generator; }
+
+static std::string GetMangledName(const clang::Decl *decl) {
+  assert(name_generator);
+  return name_generator->getName(decl);
+}
+
 static std::string GetLexicalSpecializationID(const clang::Decl *decl) {
   auto &ctx = decl->getASTContext();
   std::string id;
   if (const auto *var =
           clang::dyn_cast<clang::VarTemplateSpecializationDecl>(decl)) {
-    id += clang::ASTNameGenerator(var->getASTContext()).getName(var);
+    id += GetMangledName(var);
   }
   if (const auto *self =
           clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(decl)) {
@@ -864,7 +877,7 @@ static std::string GetLexicalSpecializationID(const clang::Decl *decl) {
     }
     if (const auto *fn = clang::dyn_cast<clang::FunctionDecl>(dc);
         fn && fn->getTemplateSpecializationArgs()) {
-      id += clang::ASTNameGenerator(fn->getASTContext()).getName(fn);
+      id += GetMangledName(fn);
     }
   }
   return id;
@@ -937,9 +950,7 @@ std::string DisambiguateAnonymousTag(const clang::TagDecl *tag) {
 static std::unordered_map<std::string, size_t> type_mapping;
 
 static size_t GetDeclId(const clang::NamedDecl *decl, bool internal) {
-  std::string key =
-      clang::ASTNameGenerator(decl->getASTContext()).getName(decl) +
-      GetParamSignature(decl);
+  std::string key = GetMangledName(decl) + GetParamSignature(decl);
   if (internal) {
     key += GetLocationID(decl);
   }

cpp2rust/converter/converter_lib.h

@@ -7,6 +7,7 @@
 #include <clang/AST/Decl.h>
 #include <clang/AST/DeclCXX.h>
 #include <clang/AST/Expr.h>
+#include <clang/AST/Mangle.h>
 #include <clang/AST/StmtCXX.h>
 #include <clang/AST/Type.h>
 #include <llvm/ADT/APSInt.h>
@@ -181,6 +182,10 @@ unsigned GetColumnNumber(const clang::Decl *decl);
 
 unsigned GetArraySize(clang::QualType array_type);
 
+void SetNameGenerator(clang::ASTNameGenerator *generator);
+
+clang::ASTNameGenerator *GetNameGenerator();
+
 std::string GetID(const clang::Decl *decl);
 std::string GetMethodID(const clang::CXXMethodDecl *decl);
 

tests/unit/out/refcount/lambda_to_fn_ptr.rs

@@ -12,10 +12,10 @@ pub fn apply_0(mut x: i32, mut fn_: FnPtr<fn(i32) -> i32>) -> i32 {
 pub fn call_nttp_1(mut x: i32) -> i32 {
     return ({ (FnPtr::<fn(i32) -> i32>::new(int_operator___int__const::__invoke))(x) });
 }
-pub fn call_nttp_1(mut x: i32) -> i32 {
+pub fn call_nttp_2(mut x: i32) -> i32 {
     return ({ (FnPtr::<fn(i32) -> i32>::new(int_operator___int__const::__invoke))(x) });
 }
-pub fn call_nttp_2(mut x: i32) -> i32 {
+pub fn call_nttp_3(mut x: i32) -> i32 {
     return ({
         FnPtr::<fn(i32) -> i32>::new(|mut x: i32| -> i32 {
             {
@@ -55,8 +55,8 @@ fn main_0() -> i32 {
     });
     assert!((({ p.call(2,) }) == 6));
     assert!((({ call_nttp_1(5,) }) == 4));
-    assert!((({ call_nttp_1(5,) }) == 50));
-    assert!((({ call_nttp_2(5,) }) == 105));
+    assert!((({ call_nttp_2(5,) }) == 50));
+    assert!((({ call_nttp_3(5,) }) == 105));
     let sum: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(FnPtr::<fn(i32) -> i32>::new(
         |n: i32| -> i32 {
             {

tests/unit/out/unsafe/lambda_to_fn_ptr.rs

@@ -12,10 +12,10 @@ pub unsafe fn apply_0(mut x: i32, mut fn_: Option<unsafe fn(i32) -> i32>) -> i32
 pub unsafe fn call_nttp_1(mut x: i32) -> i32 {
     return (unsafe { (Some(int_operator___int__const::__invoke))(x) });
 }
-pub unsafe fn call_nttp_1(mut x: i32) -> i32 {
+pub unsafe fn call_nttp_2(mut x: i32) -> i32 {
     return (unsafe { (Some(int_operator___int__const::__invoke))(x) });
 }
-pub unsafe fn call_nttp_2(mut x: i32) -> i32 {
+pub unsafe fn call_nttp_3(mut x: i32) -> i32 {
     return (unsafe {
         FnPtr::<fn(i32) -> i32>::new(|mut x: i32| -> i32 {
             unsafe {
@@ -70,8 +70,8 @@ unsafe fn main_0() -> i32 {
     });
     assert!(((unsafe { (p).unwrap()(2,) }) == (6)));
     assert!(((unsafe { call_nttp_1(5,) }) == (4)));
-    assert!(((unsafe { call_nttp_1(5,) }) == (50)));
-    assert!(((unsafe { call_nttp_2(5,) }) == (105)));
+    assert!(((unsafe { call_nttp_2(5,) }) == (50)));
+    assert!(((unsafe { call_nttp_3(5,) }) == (105)));
     let mut sum: FnPtr<fn(i32) -> i32> = FnPtr::<fn(i32) -> i32>::new(|mut n: i32| -> i32 {
         unsafe {
             let mut ap: *const VaArg = ::std::ptr::null();