Add a capability of class template instantiation arguments.

Author: vgvassilev

include/clang/Interpreter/CppInterOp.h

@@ -459,7 +459,7 @@ namespace Cpp {
   std::string ObjToString(const char *type, void *obj);
 
   struct TemplateArgInfo {
-    TCppScope_t m_Type;
+    TCppType_t m_Type;
     const char* m_IntegralValue;
     TemplateArgInfo(TCppScope_t type, const char* integral_value = nullptr)
       : m_Type(type), m_IntegralValue(integral_value) {}
@@ -468,6 +468,9 @@ namespace Cpp {
                                        TemplateArgInfo* template_args,
                                        size_t template_args_size);
 
+  /// Returns the class template instantiation arguments of \c templ_instance.
+  void GetClassTemplateInstantiationArgs(TCppScope_t templ_instance,
+                                         std::vector<TemplateArgInfo> &args);
   std::vector<std::string> GetAllCppNames(TCppScope_t scope);
 
   void DumpScope(TCppScope_t scope);

lib/Interpreter/CppInterOp.cpp

@@ -2696,6 +2696,30 @@ namespace Cpp {
     return GetScopeFromType(Instance);
   }
 
+  void GetClassTemplateInstantiationArgs(TCppScope_t templ_instance,
+                                         std::vector<TemplateArgInfo> &args) {
+    auto* CTSD = static_cast<ClassTemplateSpecializationDecl*>(templ_instance);
+    for(const auto& TA : CTSD->getTemplateInstantiationArgs().asArray()) {
+      switch (TA.getKind()) {
+      default:
+        assert(0 && "Not yet supported!");
+        break;
+      case TemplateArgument::Pack:
+        for (auto SubTA : TA.pack_elements())
+          args.push_back({SubTA.getAsType().getAsOpaquePtr()});
+        break;
+      case TemplateArgument::Integral:
+        // FIXME: Support this case where the problem is where we provide the
+        // storage for the m_IntegralValue.
+        //llvm::APSInt Val = TA.getAsIntegral();
+        //args.push_back({TA.getIntegralType(), TA.getAsIntegral()})
+        //break;
+      case TemplateArgument::Type:
+        args.push_back({TA.getAsType().getAsOpaquePtr()});
+      }
+    }
+  }
+
   std::vector<std::string> GetAllCppNames(TCppScope_t scope) {
     auto *D = (clang::Decl *)scope;
     clang::DeclContext *DC;

unittests/CppInterOp/ScopeReflectionTest.cpp

@@ -797,6 +797,43 @@ TEST(ScopeReflectionTest, InstantiateClassTemplate) {
   EXPECT_TRUE(TA4_1.getAsIntegral() == 3);
 }
 
+TEST(ScopeReflectionTest, GetClassTemplateInstantiationArgs) {
+  std::vector<Decl *> Decls;
+  std::string code = R"(
+    template<typename ...T> struct __Cppyy_AppendTypesSlow {};
+    __Cppyy_AppendTypesSlow<int, float, double> v1;
+    __Cppyy_AppendTypesSlow<int> v2;
+    __Cppyy_AppendTypesSlow<> v3;
+  )";
+
+  GetAllTopLevelDecls(code, Decls);
+
+  auto *v1 = Cpp::GetNamed("v1");
+  auto *v2 = Cpp::GetNamed("v2");
+  auto *v3 = Cpp::GetNamed("v3");
+  EXPECT_TRUE(v1 && v2 && v3);
+
+  auto *v1_class = Cpp::GetScopeFromType(Cpp::GetVariableType(v1));
+  auto *v2_class = Cpp::GetScopeFromType(Cpp::GetVariableType(v2));
+  auto *v3_class = Cpp::GetScopeFromType(Cpp::GetVariableType(v3));
+  EXPECT_TRUE(v1_class && v2_class && v3_class);
+
+  std::vector<Cpp::TemplateArgInfo> instance_types;
+
+  Cpp::GetClassTemplateInstantiationArgs(v1_class, instance_types);
+  EXPECT_TRUE(instance_types.size() == 3);
+
+  instance_types.clear();
+
+  Cpp::GetClassTemplateInstantiationArgs(v2_class, instance_types);
+  EXPECT_TRUE(instance_types.size() == 1);
+
+  instance_types.clear();
+
+  Cpp::GetClassTemplateInstantiationArgs(v3_class, instance_types);
+  EXPECT_TRUE(instance_types.size() == 0);
+}
+
 TEST(ScopeReflectionTest, IncludeVector) {
   std::string code = R"(
     #include <vector>