[WIP] Things required to get Python Type-Hints to work with cppyy

include/CppInterOp/CppInterOp.h

@@ -301,7 +301,10 @@ CPPINTEROP_API size_t SizeOf(TCppScope_t scope);
 /// Checks if it is a "built-in" or a "complex" type.
 CPPINTEROP_API bool IsBuiltin(TCppType_t type);
 
-/// Checks if it is a templated class.
+/// Checks if it is a template class.
+CPPINTEROP_API bool IsTemplateClass(TCppScope_t handle);
+
+/// Checks if it is a template.
 CPPINTEROP_API bool IsTemplate(TCppScope_t handle);
 
 /// Checks if it is a class template specialization class.
@@ -373,6 +376,8 @@ CPPINTEROP_API bool IsVariable(TCppScope_t scope);
 /// namespace, variable, or a function).
 CPPINTEROP_API std::string GetName(TCppScope_t klass);
 
+CPPINTEROP_API std::string GetDocString(TCppScope_t scope);
+
 /// This is similar to GetName() function, but besides
 /// the name, it also gets the template arguments.
 CPPINTEROP_API std::string GetCompleteName(TCppScope_t klass);
@@ -437,6 +442,12 @@ CPPINTEROP_API bool IsSubclass(TCppScope_t derived, TCppScope_t base);
 CPPINTEROP_API int64_t GetBaseClassOffset(TCppScope_t derived,
                                           TCppScope_t base);
 
+CPPINTEROP_API void GetDatamembersInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members);
+CPPINTEROP_API void GetFunctionsInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members);
+CPPINTEROP_API void GetClassInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members);
+CPPINTEROP_API void GetTemplatedClassInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members);
+CPPINTEROP_API void GetTemplatedFunctionsInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members);
+
 /// Sets a list of all the Methods that are in the Class that is
 /// supplied as a parameter.
 ///\param[in] klass - Pointer to the scope/class under which the methods have
@@ -490,6 +501,8 @@ CPPINTEROP_API std::string GetFunctionSignature(TCppFunction_t func);
 ///\returns if a function was marked as \c =delete.
 CPPINTEROP_API bool IsFunctionDeleted(TCppConstFunction_t function);
 
+CPPINTEROP_API bool IsTemplateInstantiationOrSpecialization(TCppScope_t scope);
+
 CPPINTEROP_API bool IsTemplatedFunction(TCppFunction_t func);
 
 /// This function performs a lookup to check if there is a
@@ -670,6 +683,12 @@ CPPINTEROP_API bool IsConstMethod(TCppFunction_t method);
 CPPINTEROP_API std::string GetFunctionArgDefault(TCppFunction_t func,
                                                  TCppIndex_t param_index);
 
+///\returns the size of template arguments
+CPPINTEROP_API TCppIndex_t GetTemplateNumArgs(TCppScope_t scope);
+
+///\returns the template argument name of template as string.
+CPPINTEROP_API std::string GetTemplateArgName(TCppScope_t scope, TCppIndex_t param_index);
+
 ///\returns the argument name of function as string.
 CPPINTEROP_API std::string GetFunctionArgName(TCppFunction_t func,
                                               TCppIndex_t param_index);

lib/CppInterOp/CppInterOp.cpp

@@ -12,6 +12,7 @@
 #include "Compatibility.h"
 
 #include "clang/AST/Attrs.inc"
+#include "clang/AST/Comment.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclAccessPair.h"
@@ -380,6 +381,11 @@
   return llvm::StringRef(Ty.getAsString()).contains("complex");
 }
 
+bool IsTemplateClass(TCppScope_t handle) {
+  auto* D = (clang::Decl*)handle;
+  return llvm::isa_and_nonnull<clang::ClassTemplateDecl>(D);
+}
+
 bool IsTemplate(TCppScope_t handle) {
   auto* D = (clang::Decl*)handle;
   return llvm::isa_and_nonnull<clang::TemplateDecl>(D);
@@ -546,6 +552,15 @@
   return llvm::isa_and_nonnull<clang::VarDecl>(D);
 }
 
+std::string GetDocString(TCppScope_t scope) {
+  auto *D = static_cast<Decl*>(scope);
+  auto &AST = getASTContext();
+  const clang::RawComment *Comment = AST.getRawCommentForAnyRedecl(D);
+  if (!Comment)
+    return "";
+  return Comment->getFormattedText(AST.getSourceManager(), AST.getDiagnostics());
+}
+
 std::string GetName(TCppType_t klass) {
   auto* D = (clang::NamedDecl*)klass;
 
@@ -877,6 +892,51 @@
   return ComputeBaseOffset(getSema().getASTContext(), DCXXRD, Paths.front());
 }
 
+template <typename DeclType>
+static void GetNamespaceDecls(TCppScope_t ns,
+                          std::vector<TCppScope_t>& members) {
+  if (!ns)
+    return;
+
+  auto* D = (clang::Decl*)ns;
+
+  if (!D || !isa<NamespaceDecl>(D))
+    return;
+
+  auto* NSD = dyn_cast<NamespaceDecl>(D)->getMostRecentDecl();
+  while (NSD) {
+    for (Decl* DI : NSD->decls()) {
+      if (auto* MD = dyn_cast<DeclType>(DI))
+        members.push_back(MD);
+      else if (auto* USD = dyn_cast<UsingShadowDecl>(DI)) {
+        if (auto *MD = dyn_cast<DeclType>(USD->getTargetDecl()))
+          members.push_back(MD);
+      }
+    }
+    NSD = NSD->getPreviousDecl();
+  }
+}
+
+void GetDatamembersInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members) {
+  GetNamespaceDecls<VarDecl>(ns, members);
+}
+
+void GetFunctionsInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members) {
+  GetNamespaceDecls<FunctionDecl>(ns, members);
+}
+
+void GetClassInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members) {
+  GetNamespaceDecls<RecordDecl>(ns, members);
+}
+
+void GetTemplatedClassInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members) {
+  GetNamespaceDecls<ClassTemplateDecl>(ns, members);
+}
+
+void GetTemplatedFunctionsInNamespace(TCppScope_t ns, std::vector<TCppScope_t>& members) {
+  GetNamespaceDecls<FunctionTemplateDecl>(ns, members);
+}
+
 template <typename DeclType>
 static void GetClassDecls(TCppScope_t klass,
                           std::vector<TCppFunction_t>& methods) {
@@ -888,6 +948,10 @@
   if (auto* TD = dyn_cast<TypedefNameDecl>(D))
     D = GetScopeFromType(TD->getUnderlyingType());
 
+  if (auto *CTD = llvm::dyn_cast_or_null<ClassTemplateDecl>(D)) {
+    D = CTD->getTemplatedDecl();
+  }
+
   if (!D || !isa<CXXRecordDecl>(D))
     return;
 
@@ -1011,7 +1075,7 @@
     QualType Type = FD->getReturnType();
     if (Type->isUndeducedAutoType()) {
       bool needInstantiation = false;
-      if (IsTemplatedFunction(FD) && !FD->isDefined())
+      if (IsTemplateInstantiationOrSpecialization(FD) && !FD->isDefined())
         needInstantiation = true;
       if (auto* MD = llvm::dyn_cast<clang::CXXMethodDecl>(FD)) {
         if (IsTemplateSpecialization(MD->getParent()))
@@ -1055,8 +1119,10 @@
 }
 
 TCppType_t GetFunctionArgType(TCppFunction_t func, TCppIndex_t iarg) {
-  auto* D = (clang::Decl*)func;
-
+  auto* D = static_cast<clang::Decl*>(func);
+  if (auto *FTD = llvm::dyn_cast_or_null<FunctionTemplateDecl>(D)) {
+    D = FTD->getTemplatedDecl();
+  }
   if (auto* FD = llvm::dyn_cast_or_null<clang::FunctionDecl>(D)) {
     if (iarg < FD->getNumParams()) {
       auto* PVD = FD->getParamDecl(iarg);
@@ -1122,7 +1188,12 @@
 
 bool IsTemplatedFunction(TCppFunction_t func) {
   auto* D = (Decl*)func;
-  return IsTemplatedFunction(D) || IsTemplateInstantiationOrSpecialization(D);
+  return IsTemplatedFunction(D) /*|| IsTemplateInstantiationOrSpecialization(D)*/;
+}
+
+bool IsTemplateInstantiationOrSpecialization(TCppScope_t scope) {
+  auto *D = static_cast<Decl*>(scope);
+  return IsTemplateInstantiationOrSpecialization(D);
 }
 
 // FIXME: This lookup is broken, and should no longer be used in favour of
@@ -1334,6 +1405,9 @@
 
 bool IsStaticMethod(TCppConstFunction_t method) {
   const auto* D = static_cast<const Decl*>(method);
+  if (auto *FTD = llvm::dyn_cast_or_null<FunctionTemplateDecl>(D)) {
+    D = FTD->getTemplatedDecl();
+  }
   if (auto* CXXMD = llvm::dyn_cast_or_null<CXXMethodDecl>(D)) {
     return CXXMD->isStatic();
   }
@@ -1404,6 +1478,9 @@
 
 void GetDatamembers(TCppScope_t scope, std::vector<TCppScope_t>& datamembers) {
   auto* D = (Decl*)scope;
+  if (auto *CTD = llvm::dyn_cast_or_null<ClassTemplateDecl>(D)) {
+    D = CTD->getTemplatedDecl();
+  }
 
   if (auto* CXXRD = llvm::dyn_cast_or_null<CXXRecordDecl>(D)) {
     getSema().ForceDeclarationOfImplicitMembers(CXXRD);
@@ -1497,7 +1574,7 @@
     QualType QT = DD->getType();
 
     // Check if the type is a typedef type
-    if (QT->isTypedefNameType()) {
+    if (QT->isTypedefNameType() || QT->getAs<clang::TemplateTypeParmType>()) {
       return QT.getAsOpaquePtr();
     }
 
@@ -1758,6 +1835,8 @@
   if (!type)
     return 0;
   QualType QT = QualType::getFromOpaquePtr(type);
+  if (QT->getAs<clang::TemplateTypeParmType>())
+    return type;
   return QT.getCanonicalType().getAsOpaquePtr();
 }
 
@@ -3841,6 +3920,25 @@
   return false;
 }
 
+TCppIndex_t GetTemplateNumArgs(TCppScope_t scope) {
+  auto *D = static_cast<Decl*>(scope);
+  if (auto *TD = llvm::dyn_cast<TemplateDecl>(D)) {
+    auto *TPL = TD->getTemplateParameters();
+    return TPL->size();
+  }
+  return -1;
+}
+
+std::string GetTemplateArgName(TCppScope_t scope, TCppIndex_t param_index) {
+  auto *D = static_cast<Decl*>(scope);
+  if (auto *TD = llvm::dyn_cast<TemplateDecl>(D)) {
+    auto *TPL = TD->getTemplateParameters();
+    NamedDecl *ND = TPL->getParam(param_index);
+    return ND->getNameAsString();
+  }
+  return "";
+}
+
 std::string GetFunctionArgName(TCppFunction_t func, TCppIndex_t param_index) {
   auto* D = (clang::Decl*)func;
   clang::ParmVarDecl* PI = nullptr;

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -929,7 +929,7 @@ TYPED_TEST(CppInterOpTest, FunctionReflectionTestInstantiateVariadicFunction) {
                                              C.IntTy.getAsOpaquePtr()};
   auto Instance1 = Cpp::InstantiateTemplate(Decls[1], args1.data(),
                                             /*type_size*/ args1.size());
-  EXPECT_TRUE(Cpp::IsTemplatedFunction(Instance1));
+  EXPECT_TRUE(Cpp::IsTemplateInstantiationOrSpecialization(Instance1));
   EXPECT_EQ(Cpp::GetFunctionSignature(Instance1),
             "template<> void VariadicFn<<double, int>>(double args, int args)");
 
@@ -952,7 +952,7 @@ TYPED_TEST(CppInterOpTest, FunctionReflectionTestInstantiateVariadicFunction) {
   // instantiate VariadicFnExtended
   auto Instance2 =
       Cpp::InstantiateTemplate(Decls[2], args2.data(), args2.size(), true);
-  EXPECT_TRUE(Cpp::IsTemplatedFunction(Instance2));
+  EXPECT_TRUE(Cpp::IsTemplateInstantiationOrSpecialization(Instance2));
 
   FunctionDecl* FD2 = cast<FunctionDecl>((Decl*)Instance2);
   FunctionDecl* FnTD2 = FD2->getTemplateInstantiationPattern();