Support typedefs over anonymous tag declarations.

That's a quite often used idiom in C which hides the implementation details of
the underlying tag declaration.

Author: vgvassilev

lib/Interpreter/CppInterOp.cpp

@@ -2194,7 +2194,12 @@ namespace Cpp {
       //
       if (const TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
         // This is a class, struct, or union member.
-        QualType QT(TD->getTypeForDecl(), 0);
+        // Handle the typedefs to anonymous types.
+        QualType QT;
+        if (const TypedefDecl *Typedef = dyn_cast<const TypedefDecl>(TD))
+          QT = Typedef->getTypeSourceInfo()->getType();
+        else
+          QT = {TD->getTypeForDecl(), 0};
         get_type_as_string(QT, class_name, Context, Policy);
       } else if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
         // This is a namespace member.

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -562,6 +562,28 @@ TEST(FunctionReflectionTest, IsVirtualMethod) {
   EXPECT_FALSE(Cpp::IsVirtualMethod(SubDecls[3])); // y()
 }
 
+TEST(FunctionReflectionTest, JitCallAdvanced) {
+  std::vector<Decl*> Decls;
+  std::string code = R"(
+      typedef struct _name {
+        _name() { p[0] = (void*)0x1; p[1] = (void*)0x2; p[2] = (void*)0x3; }
+        void* p[3];
+      } name;
+    )";
+
+  GetAllTopLevelDecls(code, Decls);
+  Sema *S = &Interp->getCI()->getSema();
+  auto *CtorD =
+      (clang::CXXConstructorDecl *)Cpp::GetDefaultConstructor(S, Decls[0]);
+  auto Ctor = Cpp::MakeFunctionCallable((Cpp::TInterp_t)Interp.get(), CtorD);
+  EXPECT_TRUE((bool)Ctor) << "Failed to build a wrapper for the ctor";
+  void* object = nullptr;
+  Ctor.Invoke(&object);
+  EXPECT_TRUE(object) << "Failed to call the ctor.";
+  // Building a wrapper with a typedef decl must be possible.
+  Cpp::Destruct((Cpp::TInterp_t)Interp.get(), object, Decls[1]);
+}
+
 TEST(FunctionReflectionTest, GetFunctionCallWrapper) {
   std::vector<Decl*> Decls;
   std::string code = R"(

unittests/CppInterOp/Utils.cpp

@@ -38,19 +38,19 @@ void TestUtils::GetAllTopLevelDecls(const std::string& code, std::vector<Decl*>&
   for (auto DCI = T->decls_begin(), E = T->decls_end(); DCI != E; ++DCI) {
     if (DCI->m_Call != cling::Transaction::kCCIHandleTopLevelDecl)
       continue;
-    assert(DCI->m_DGR.isSingleDecl());
-    if (filter_implicitGenerated && (DCI->m_DGR.getSingleDecl())->isImplicit())
-      continue;
-    Decls.push_back(DCI->m_DGR.getSingleDecl());
+    for (Decl *D : DCI->m_DGR) {
+      if (filter_implicitGenerated && D->isImplicit())
+        continue;
+      Decls.push_back(D);
+    }
   }
 #else
   PartialTranslationUnit *T = nullptr;
   Interp->process(code, /*Value*/nullptr, &T);
-  for (auto DCI = T->TUPart->decls_begin(), E = T->TUPart->decls_end();
-       DCI != E; ++DCI) {
-    if (filter_implicitGenerated && (*DCI)->isImplicit())
+  for (auto *D : T->TUPart->decls()) {
+    if (filter_implicitGenerated && D->isImplicit())
       continue;
-    Decls.push_back(*DCI);
+    Decls.push_back(D);
   }
 #endif
 }