Prefer mangled name over printer

Author: lucic71

cpp2rust/converter/converter.h

@@ -35,15 +35,15 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
                      const char *keyword_mut = keyword::kMut)
       : rs_code_(&rs_code), ctx_(ctx), keyword_unsafe_(keyword_unsafe),
         keyword_mut_(keyword_mut) {
-    if (!GetNameGenerator()) {
-      name_generator_ = std::make_unique<clang::ASTNameGenerator>(ctx);
-      SetNameGenerator(name_generator_.get());
+    if (!GetMangleContext()) {
+      mangle_context_.reset(ctx.createMangleContext());
+      SetMangleContext(mangle_context_.get());
     }
   }
 
   virtual ~Converter() {
-    if (name_generator_) {
-      SetNameGenerator(nullptr);
+    if (mangle_context_) {
+      SetMangleContext(nullptr);
     }
   }
 
@@ -806,7 +806,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   std::string *rs_code_;
   clang::ASTContext &ctx_;
-  std::unique_ptr<clang::ASTNameGenerator> name_generator_;
+  std::unique_ptr<clang::MangleContext> mangle_context_;
   clang::FunctionDecl *curr_function_ = nullptr;
   bool in_function_formals_ = false;
   enum class MethodTarget : uint8_t {

cpp2rust/converter/converter_lib.cpp

@@ -28,7 +28,6 @@
 
 #include "converter/lex.h"
 #include "converter/mapper.h"
-#include "converter/printer.h"
 #include "converter/rules/registry.h"
 
 // https://doc.rust-lang.org/reference/keywords.html
@@ -863,40 +862,64 @@ static std::string GetParamSignature(const clang::Decl *decl) {
   return args;
 }
 
-static clang::ASTNameGenerator *name_generator = nullptr;
+static clang::MangleContext *mangle_context = nullptr;
 
-void SetNameGenerator(clang::ASTNameGenerator *generator) {
-  name_generator = generator;
+void SetMangleContext(clang::MangleContext *context) {
+  mangle_context = context;
 }
 
-clang::ASTNameGenerator *GetNameGenerator() { return name_generator; }
+clang::MangleContext *GetMangleContext() { return mangle_context; }
 
 static std::string GetMangledName(const clang::Decl *decl) {
-  assert(name_generator);
-  return name_generator->getName(decl);
+  assert(mangle_context);
+  auto *named = clang::cast<clang::NamedDecl>(decl);
+  if (!mangle_context->shouldMangleDeclName(named)) {
+    return named->getNameAsString();
+  }
+  clang::GlobalDecl global;
+  if (auto *ctor = clang::dyn_cast<clang::CXXConstructorDecl>(decl)) {
+    global = clang::GlobalDecl(ctor, clang::Ctor_Complete);
+  } else if (auto *dtor = clang::dyn_cast<clang::CXXDestructorDecl>(decl)) {
+    global = clang::GlobalDecl(dtor, clang::Dtor_Complete);
+  } else {
+    global = clang::GlobalDecl(named);
+  }
+  std::string name;
+  llvm::raw_string_ostream os(name);
+  mangle_context->mangleName(global, os);
+  return name;
+}
+
+static std::string
+GetMangledTypeName(const clang::ClassTemplateSpecializationDecl *decl) {
+  assert(mangle_context);
+  std::string name;
+  llvm::raw_string_ostream os(name);
+  mangle_context->mangleCanonicalTypeName(
+      decl->getASTContext().getCanonicalTagType(decl), os);
+  return name;
 }
 
 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 += GetMangledName(var);
   }
   if (const auto *self =
           clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(decl)) {
-    id += Printer::ToString(ctx, GetTypeForDecl(ctx, self));
+    id += GetMangledTypeName(self);
   }
   if (const auto *spec =
           clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(
               decl->getLexicalDeclContext());
       spec && decl->getLexicalDeclContext() != decl->getDeclContext()) {
-    id += Printer::ToString(ctx, GetTypeForDecl(ctx, spec));
+    id += GetMangledTypeName(spec);
   }
   for (const auto *dc = decl->getDeclContext(); dc; dc = dc->getParent()) {
     if (const auto *spec =
             clang::dyn_cast<clang::ClassTemplateSpecializationDecl>(dc)) {
-      id += Printer::ToString(ctx, GetTypeForDecl(ctx, spec));
+      id += GetMangledTypeName(spec);
     }
     if (const auto *fn = clang::dyn_cast<clang::FunctionDecl>(dc);
         fn && fn->getTemplateSpecializationArgs()) {

cpp2rust/converter/converter_lib.h

@@ -188,9 +188,9 @@ unsigned GetColumnNumber(const clang::Decl *decl);
 
 unsigned GetArraySize(clang::QualType array_type);
 
-void SetNameGenerator(clang::ASTNameGenerator *generator);
+void SetMangleContext(clang::MangleContext *context);
 
-clang::ASTNameGenerator *GetNameGenerator();
+clang::MangleContext *GetMangleContext();
 
 std::string GetID(const clang::Decl *decl);
 std::string GetMethodID(const clang::CXXMethodDecl *decl);