fix: codegen for nested namespace with using (#612)

Author: Vipul-Cariappa

lib/CppInterOp/CppInterOp.cpp

@@ -547,7 +547,13 @@ std::string GetQualifiedCompleteName(TCppType_t klass) {
     if (auto* TD = llvm::dyn_cast<TagDecl>(ND)) {
       std::string type_name;
       QualType QT = C.getTagDeclType(TD);
-      QT.getAsStringInternal(type_name, C.getPrintingPolicy());
+      PrintingPolicy PP = C.getPrintingPolicy();
+      PP.FullyQualifiedName = true;
+      PP.SuppressUnwrittenScope = true;
+#if CLANG_VERSION_MAJOR > 16
+      PP.SuppressElaboration = true;
+#endif
+      QT.getAsStringInternal(type_name, PP);
 
       return type_name;
     }
@@ -630,7 +636,8 @@ TCppScope_t GetScope(const std::string& name, TCppScope_t parent) {
     return 0;
 
   if (llvm::isa<NamespaceDecl>(ND) || llvm::isa<RecordDecl>(ND) ||
-      llvm::isa<ClassTemplateDecl>(ND) || llvm::isa<TypedefNameDecl>(ND))
+      llvm::isa<ClassTemplateDecl>(ND) || llvm::isa<TypedefNameDecl>(ND) ||
+      llvm::isa<TypeAliasTemplateDecl>(ND) || llvm::isa<TypeAliasDecl>(ND))
     return (TCppScope_t)(ND->getCanonicalDecl());
 
   return 0;
@@ -2012,7 +2019,13 @@ void make_narg_call(const FunctionDecl* FD, const std::string& return_type,
     {
       std::string complete_name;
       llvm::raw_string_ostream stream(complete_name);
-      FD->getNameForDiagnostic(stream, FD->getASTContext().getPrintingPolicy(),
+      PrintingPolicy PP = FD->getASTContext().getPrintingPolicy();
+      PP.FullyQualifiedName = true;
+      PP.SuppressUnwrittenScope = true;
+#if CLANG_VERSION_MAJOR > 16
+      PP.SuppressElaboration = true;
+#endif
+      FD->getNameForDiagnostic(stream, PP,
                                /*Qualified=*/false);
 
       // insert space between template argument list and the function name

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -1733,6 +1733,87 @@ TEST(FunctionReflectionTest, GetFunctionCallWrapper) {
       Cpp::BestOverloadFunctionMatch(operators, {}, {K1, K2});
   auto chrono_op_fn_callable = Cpp::MakeFunctionCallable(kop);
   EXPECT_EQ(chrono_op_fn_callable.getKind(), Cpp::JitCall::kGenericCall);
+
+  Interp->process(R"(
+    namespace my_std {
+    template <typename T1, typename T2>
+    struct pair {
+        T1 first;
+        T2 second;
+        pair(T1 fst, T2 snd) : first(fst), second(snd) {}
+    };
+
+    template <typename T1, typename T2>
+    pair<T1, T2> make_pair(T1 x, T2 y) {
+        return pair<T1, T2>(x, y);
+    }
+
+    template <int _Int>
+    struct __pair_get;
+
+    template <>
+    struct __pair_get<0> {
+        template <typename T1, typename T2>
+        static constexpr T1 __get(pair<T1, T2> __pair) noexcept {
+            return __pair.first;
+        }
+    };
+
+    template <>
+    struct __pair_get<1> {
+        template <typename T1, typename T2>
+        constexpr T2 __get(pair<T1, T2> __pair) noexcept {
+            return __pair.second;
+        }
+    };
+
+    template <int N, typename T1, typename T2>
+    static constexpr auto get(pair<T1, T2> __t) noexcept {
+        return __pair_get<N>::__get(__t);
+    }
+    }  // namespace my_std
+
+    namespace libchemist {
+    namespace type {
+    template <typename T>
+    class tensor {};
+    }  // namespace type
+
+    template <typename element_type = double,
+              typename tensor_type = type::tensor<element_type>>
+    class CanonicalMO {};
+
+    template class CanonicalMO<double, type::tensor<double>>;
+
+    auto produce() { return my_std::make_pair(10., type::tensor<double>{}); }
+
+    }  // namespace libchemist
+
+    namespace property_types {
+    namespace type {
+    template <typename T>
+    using canonical_mos = libchemist::CanonicalMO<T>;
+    }
+
+    auto produce() { return my_std::make_pair(5., type::canonical_mos<double>{}); }
+    }  // namespace property_types
+
+    auto tmp = property_types::produce();
+    auto &p = tmp;
+  )");
+
+  std::vector<Cpp::TCppFunction_t> unresolved_candidate_methods;
+  Cpp::GetClassTemplatedMethods("get", Cpp::GetScope("my_std"),
+                                unresolved_candidate_methods);
+  Cpp::TCppType_t p = Cpp::GetTypeFromScope(Cpp::GetNamed("p"));
+  EXPECT_TRUE(p);
+
+  Cpp::TCppScope_t fn = Cpp::BestOverloadFunctionMatch(
+      unresolved_candidate_methods, {{Cpp::GetType("int"), "0"}}, {p});
+  EXPECT_TRUE(fn);
+
+  auto fn_callable = Cpp::MakeFunctionCallable(fn);
+  EXPECT_EQ(fn_callable.getKind(), Cpp::JitCall::kGenericCall);
 }
 
 TEST(FunctionReflectionTest, IsConstMethod) {