fix MakeFunctionCallable for dealing with public typedef to private type

Author: Vipul-Cariappa

lib/Interpreter/CppInterOp.cpp

@@ -1600,7 +1600,12 @@ namespace Cpp {
                             PrintingPolicy Policy) {
       //TODO: Implement cling desugaring from utils::AST
       //      cling::utils::Transform::GetPartiallyDesugaredType()
-      QT = QT.getDesugaredType(C);
+      if (!QT->isTypedefNameType() || QT->isBuiltinType())
+        QT = QT.getDesugaredType(C);
+#if CLANG_VERSION_MAJOR > 16
+      Policy.SuppressElaboration = true;
+#endif
+      Policy.FullyQualifiedName = true;
       QT.getAsStringInternal(type_name, Policy);
     }
 
@@ -1652,13 +1657,13 @@ namespace Cpp {
         return;
       } else if (QT->isPointerType()) {
         isPointer = true;
-        QT = cast<clang::PointerType>(QT)->getPointeeType();
+        QT = cast<clang::PointerType>(QT.getCanonicalType())->getPointeeType();
       } else if (QT->isReferenceType()) {
         if (QT->isRValueReferenceType())
           refType = kRValueReference;
         else
           refType = kLValueReference;
-        QT = cast<ReferenceType>(QT)->getPointeeType();
+        QT = cast<ReferenceType>(QT.getCanonicalType())->getPointeeType();
       }
       // Fall through for the array type to deal with reference/pointer ro array
       // type.
@@ -1911,7 +1916,7 @@ namespace Cpp {
         make_narg_ctor_with_return(FD, N, class_name, buf, indent_level);
         return;
       }
-      QualType QT = FD->getReturnType().getCanonicalType();
+      QualType QT = FD->getReturnType();
       if (QT->isVoidType()) {
         std::ostringstream typedefbuf;
         std::ostringstream callbuf;

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -974,6 +974,53 @@ TEST(FunctionReflectionTest, GetFunctionCallWrapper) {
 
   FCI_Add.Invoke(&result, {args, /*args_size=*/2});
   EXPECT_EQ(result, a + b);
+
+  // call with pointers
+  Interp->process(R"(
+  void set_5(int *out) {
+    *out = 5;
+  }
+  )");
+
+  Cpp::TCppScope_t set_5 = Cpp::GetNamed("set_5");
+  EXPECT_TRUE(set_5);
+
+  Cpp::JitCall set_5_f = Cpp::MakeFunctionCallable(set_5);
+  EXPECT_EQ(set_5_f.getKind(), Cpp::JitCall::kGenericCall);
+
+  int* bp = &b;
+  void* set_5_args[1] = {(void*)&bp};
+  set_5_f.Invoke(nullptr, {set_5_args, 1});
+  EXPECT_EQ(b, 5);
+
+  // typedef resolution testing
+  Interp->process(R"(
+  class TypedefToPrivateClass {
+  private:
+    class PC {
+    public:
+      int m_val = 4;
+    };
+
+  public:
+    typedef PC PP;
+    static PP f() { return PC(); }
+  };
+  )");
+
+  Cpp::TCppScope_t TypedefToPrivateClass =
+      Cpp::GetNamed("TypedefToPrivateClass");
+  EXPECT_TRUE(TypedefToPrivateClass);
+
+  Cpp::TCppScope_t f = Cpp::GetNamed("f", TypedefToPrivateClass);
+  EXPECT_TRUE(f);
+
+  Cpp::JitCall FCI_f = Cpp::MakeFunctionCallable(f);
+  EXPECT_EQ(FCI_f.getKind(), Cpp::JitCall::kGenericCall);
+
+  void* res = nullptr;
+  FCI_f.Invoke(&res, {nullptr, 0});
+  EXPECT_TRUE(res);
 }
 
 TEST(FunctionReflectionTest, IsConstMethod) {