From 389952a925d6ad79e1695e4f28969101479d8753 Mon Sep 17 00:00:00 2001
From: Raiki Tamura <tamaron1203@gmail.com>
Date: Tue, 19 Sep 2023 18:11:05 +0900
Subject: [PATCH] wip [skip ci]

---
 gcc/rust/backend/rust-mangle.cc | 98 ++++++++++++++++++++++++++-------
 1 file changed, 78 insertions(+), 20 deletions(-)

diff --git a/gcc/rust/backend/rust-mangle.cc b/gcc/rust/backend/rust-mangle.cc
index 5526a49666e..fb42caa9b8a 100644
--- a/gcc/rust/backend/rust-mangle.cc
+++ b/gcc/rust/backend/rust-mangle.cc
@@ -4,6 +4,7 @@
 #include "rust-base62.h"
 #include "rust-unicode.h"
 #include "rust-diagnostics.h"
+#include "rust-hir-full-decls.h"
 #include "rust-system.h"
 #include "rust-unicode.h"
 #include "rust-punycode.h"
@@ -298,41 +299,94 @@ v0_identifier (const std::string &identifier)
 }
 
 static std::string
-v0_path (const Resolver::CanonicalPath &path)
+v0_path (const TyTy::BaseType *ty, const Resolver::CanonicalPath &path)
 {
-  std::cout << "mangle path " << path.get () << std::endl;
   auto mappings = Analysis::Mappings::get ();
 
   std::string prefixes;
   std::string segments;
 
   path.iterate_segs ([&] (const Resolver::CanonicalPath &path) {
-    std::cout << "lookup path seg " << path.get () << std::endl;
+    // std::cout << "lookup path seg " << path.get () << std::endl;
+    // Crate or closure
     HirId hir_id;
     if (!mappings->lookup_node_to_hir (path.get_node_id (), &hir_id))
       rust_unreachable ();
+
+    HirId parent_impl_id = UNKNOWN_HIRID;
+    HIR::ImplItem *impl_item
+      = mappings->lookup_hir_implitem (hir_id, &parent_impl_id);
+    HIR::TraitItem *trait_item = mappings->lookup_hir_trait_item (hir_id);
     HIR::Item *item = mappings->lookup_hir_item (hir_id);
-    if (item == nullptr)
-      prefixes.insert (0, "C");
-    else
+
+    if (impl_item != nullptr)
+      {
+	switch (impl_item->get_impl_item_type ())
+	  {
+	  case HIR::ImplItem::FUNCTION:
+	    prefixes.insert (0, "Nv");
+	    // TODO: generics
+	    break;
+	  case HIR::ImplItem::CONSTANT:
+	    prefixes.insert (0, "Nv");
+	    break;
+	  default:
+	    rust_unreachable ();
+	  }
+      }
+    else if (trait_item != nullptr)
+      {
+	switch (trait_item->get_item_kind ())
+	  {
+	  case HIR::TraitItem::FUNC:
+	    prefixes.insert (0, "Nv");
+	    // TODO: generics
+	    break;
+	  case HIR::TraitItem::CONST:
+	    prefixes.insert (0, "Nv");
+	    break;
+	  default:
+	    rust_unreachable ();
+	  }
+      }
+    else if (item != nullptr)
       switch (item->get_item_kind ())
 	{
-	case HIR::Item::ItemKind::Module:
 	case HIR::Item::ItemKind::Function:
 	  prefixes.insert (0, "Nv");
+	  // TODO: generics
+	  break;
+	case HIR::Item::ItemKind::Module:
+	case HIR::Item::ItemKind::Static:
+	case HIR::Item::ItemKind::Constant:
+	  prefixes.insert (0, "Nv");
+	  break;
+	case HIR::Item::ItemKind::Struct:
+	case HIR::Item::ItemKind::Enum:
+	case HIR::Item::ItemKind::Union:
+	  prefixes.insert (0, "Nt");
+	  break;
+	case HIR::Item::ItemKind::Impl:
+	  prefixes.insert (0, "M");
 	  break;
 	default:
 	  // TODO: implement other kinds
 	  rust_unreachable ();
 	}
+    if (item != nullptr)
+      {
+	std::string crate_disambiguator
+	  = v0_disambiguator (path.get_crate_num ());
+	prefixes.insert (0, "C" + crate_disambiguator);
+	// std::cout << "crate_disambiguator " << crate_disambiguator <<
+	// std::endl;
+      }
     segments += v0_identifier (path.get ());
     return true;
   });
-  std::string crate_disambiguator = v0_disambiguator (path.get_crate_num ());
-  std::cout << "prefixes " << prefixes << std::endl;
-  std::cout << "segments " << segments << std::endl;
-  std::cout << "crate_disambiguator " << crate_disambiguator << std::endl;
-  return prefixes + crate_disambiguator + segments;
+  // std::cout << "prefixes " << prefixes << std::endl;
+  // std::cout << "segments " << segments << std::endl;
+  return prefixes + segments;
 }
 
 static std::string
@@ -360,23 +414,27 @@ legacy_mangle_item (const TyTy::BaseType *ty,
 static std::string
 v0_mangle_item (const TyTy::BaseType *ty, const Resolver::CanonicalPath &path)
 {
+  rust_debug("Start mangle: %s", path.get().c_str());
   // we can get this from the canonical_path
-  auto mappings = Analysis::Mappings::get ();
-  std::string crate_name;
-  bool ok = mappings->get_crate_name (path.get_crate_num (), crate_name);
-  rust_assert (ok);
+  
+  // auto mappings = Analysis::Mappings::get ();
+  //std::string crate_name;
+  //bool ok = mappings->get_crate_name (path.get_crate_num (), crate_name);
+  //rust_assert (ok);
 
   std::stringstream mangled;
   // FIXME: Add real algorithm once all pieces are implemented
   mangled << "_R";
-  mangled << v0_path (path);
+  mangled << v0_path (ty, path);
   // auto ty_prefix = v0_type_prefix (ty);
 
-  std::cout << "mangled: " << path.get () << " to " << mangled.str ()
+  std::cout << "mangled: `" << path.get () << "` => `" << mangled.str () << "`"
 	    << std::endl;
+  rust_debug ("v0 mangle: %s => %s", path.get ().c_str (),
+	      mangled.str ().c_str ());
 
-  //std::cout << "fancy abort" << std::endl;
-  //rust_unreachable ();
+  // std::cout << "fancy abort" << std::endl;
+  // rust_unreachable ();
   return mangled.str ();
 }