[cxx-interop] Fix the printing of types with generic arguments

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -39,13 +39,14 @@
 #include "swift/Parse/Lexer.h"
 #include "swift/Parse/Parser.h"
 
+#include "SwiftToClangInteropContext.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
-#include "SwiftToClangInteropContext.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
 using namespace swift::objc_translation;
@@ -561,8 +562,8 @@ class DeclAndTypePrinter::Implementation
               outOfLineOS << "    return swift::";
               outOfLineOS << cxx_synthesis::getCxxImplNamespaceName();
               outOfLineOS << "::implClassFor<";
-              outOfLineSyntaxPrinter.printNominalTypeReference(
-                  objectTypeDecl,
+              owningPrinter.printTypeName(
+                  outOfLineOS, paramType,
                   elementDecl->getParentEnum()->getModuleContext());
               outOfLineOS << ">::type";
               if (!isOptional && isa<ClassDecl>(objectTypeDecl)) {
@@ -574,8 +575,8 @@ class DeclAndTypePrinter::Implementation
                 outOfLineOS << "      swift::"
                             << cxx_synthesis::getCxxImplNamespaceName();
                 outOfLineOS << "::implClassFor<";
-                outOfLineSyntaxPrinter.printNominalTypeReference(
-                    objectTypeDecl,
+                owningPrinter.printTypeName(
+                    outOfLineOS, paramType,
                     elementDecl->getParentEnum()->getModuleContext());
                 outOfLineOS << ">::type";
                 outOfLineOS << "::initializeWithTake(result, "
@@ -729,31 +730,36 @@ class DeclAndTypePrinter::Implementation
                     objectTypeDecl =
                         paramType->getNominalOrBoundGenericNominal();
                     outOfLineOS << "    alignas(";
-                    outOfLineSyntaxPrinter.printNominalTypeReference(
-                        objectTypeDecl, ED->getModuleContext());
+                    owningPrinter.printTypeName(
+                        outOfLineOS, paramType,
+                        elementDecl->getParentEnum()->getModuleContext());
                     outOfLineOS << ") unsigned char buffer[sizeof(";
-                    outOfLineSyntaxPrinter.printNominalTypeReference(
-                        objectTypeDecl, ED->getModuleContext());
+                    owningPrinter.printTypeName(
+                        outOfLineOS, paramType,
+                        elementDecl->getParentEnum()->getModuleContext());
                     outOfLineOS << ")];\n";
                     outOfLineOS << "    auto *valCopy = new(buffer) ";
-                    outOfLineSyntaxPrinter.printNominalTypeReference(
-                        objectTypeDecl, ED->getModuleContext());
+                    owningPrinter.printTypeName(
+                        outOfLineOS, paramType,
+                        elementDecl->getParentEnum()->getModuleContext());
                     outOfLineOS << "(val);\n";
                     outOfLineOS << "    ";
                     outOfLineOS << cxx_synthesis::getCxxSwiftNamespaceName()
                                 << "::";
                     outOfLineOS << cxx_synthesis::getCxxImplNamespaceName();
                     outOfLineOS << "::implClassFor<";
-                    outOfLineSyntaxPrinter.printNominalTypeReference(
-                        objectTypeDecl, ED->getModuleContext());
+                    owningPrinter.printTypeName(
+                        outOfLineOS, paramType,
+                        elementDecl->getParentEnum()->getModuleContext());
                     outOfLineOS << ">::type::initializeWithTake(result._"
                                    "getOpaquePointer(), ";
                     outOfLineOS << cxx_synthesis::getCxxSwiftNamespaceName()
                                 << "::";
                     outOfLineOS << cxx_synthesis::getCxxImplNamespaceName();
                     outOfLineOS << "::implClassFor<";
-                    outOfLineSyntaxPrinter.printNominalTypeReference(
-                        objectTypeDecl, ED->getModuleContext());
+                    owningPrinter.printTypeName(
+                        outOfLineOS, paramType,
+                        elementDecl->getParentEnum()->getModuleContext());
                     outOfLineOS << ">::type::getOpaquePointer(*valCopy)";
                     outOfLineOS << ");\n";
                   }
@@ -2958,6 +2964,15 @@ void DeclAndTypePrinter::print(Type ty) {
   getImpl().print(ty, /*overridingOptionality*/ std::nullopt);
 }
 
+void DeclAndTypePrinter::printTypeName(raw_ostream &os, Type ty,
+                                       const ModuleDecl *moduleContext) {
+  std::string dummy;
+  llvm::raw_string_ostream dummyOS(dummy);
+  DeclAndTypeClangFunctionPrinter printer(os, dummyOS, typeMapping,
+                                          interopContext, *this);
+  printer.printTypeName(ty, moduleContext);
+}
+
 void DeclAndTypePrinter::printAvailability(raw_ostream &os, const Decl *D) {
   getImpl().printAvailability(os, D);
 }

lib/PrintAsClang/DeclAndTypePrinter.h

@@ -16,6 +16,7 @@
 #include "OutputLanguageMode.h"
 
 #include "swift/AST/Decl.h"
+#include "swift/AST/Module.h"
 #include "swift/AST/Type.h"
 // for OptionalTypeKind
 #include "swift/ClangImporter/ClangImporter.h"
@@ -117,6 +118,9 @@ class DeclAndTypePrinter {
   void print(const Decl *D);
   void print(Type ty);
 
+  /// Prints the name of the type including generic arguments.
+  void printTypeName(raw_ostream &os, Type ty, const ModuleDecl *moduleContext);
+
   void printAvailability(raw_ostream &os, const Decl *D);
 
   /// Is \p ED empty of members and protocol conformances to include?

lib/PrintAsClang/PrintClangFunction.cpp

@@ -1760,3 +1760,13 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::getTypeRepresentation(
   return typePrinter.visit(ty, OptionalTypeKind::OTK_None,
                            /*isInOutParam=*/false);
 }
+
+void DeclAndTypeClangFunctionPrinter::printTypeName(
+    Type ty, const ModuleDecl *moduleContext) {
+  CFunctionSignatureTypePrinterModifierDelegate delegate;
+  CFunctionSignatureTypePrinter typePrinter(
+      os, cPrologueOS, typeMapping, OutputLanguageMode::Cxx, interopContext,
+      delegate, moduleContext, declPrinter,
+      FunctionSignatureTypeUse::TypeReference);
+  typePrinter.visit(ty, std::nullopt, /*isInOut=*/false);
+}

lib/PrintAsClang/PrintClangFunction.h

@@ -170,6 +170,9 @@ class DeclAndTypeClangFunctionPrinter {
                         DeclAndTypePrinter &declPrinter,
                         const ModuleDecl *emittedModule, Type ty);
 
+  /// Prints the name of the type including generic arguments.
+  void printTypeName(Type ty, const ModuleDecl *moduleContext);
+
 private:
   void printCxxToCFunctionParameterUse(Type type, StringRef name,
                                        const ModuleDecl *moduleContext,

test/Interop/SwiftToCxx/enums/enum-associated-value-class-type-cxx.cpp

@@ -52,6 +52,19 @@ int main() {
         assert(c.getX() == 5678);
     }
 
+    {
+      auto c = C::init(5);
+      auto arr = swift::Array<C>::init(c, 2);
+      auto f = F::b(arr);
+      assert(f.getB().getCount() == 2);
+    }
+
+    {
+      auto arr = swift::Array<swift::Int>::init(42, 2);
+      auto g = G<swift::Int>::b(arr);
+      assert(g.getB().getCount() == 2);
+    }
+
     assert(getRetainCount(c) == 1);
     return 0;
 }

test/Interop/SwiftToCxx/enums/enum-associated-value-class-type-cxx.swift

@@ -29,6 +29,16 @@ extension E {
   }
 }
 
+public enum F {
+  case a(Int)
+  case b([C])
+}
+
+public enum G<T> {
+  case a(Int)
+  case b([T])
+}
+
 // CHECK:      SWIFT_INLINE_THUNK E E::_impl_c::operator()(const C& val) const {
 // CHECK-NEXT:   auto result = E::_make();
 // CHECK-NEXT:   auto op = swift::_impl::_impl_RefCountedClass::copyOpaquePointer(val);
@@ -47,3 +57,23 @@ extension E {
 
 // CHECK: SWIFT_INLINE_THUNK bool E::matchesIntValue(swift::Int value) const {
 // CHECK-NEXT: return _impl::$s5Enums1EO15matchesIntValueySbSiF(value, _impl::swift_interop_passDirect_Enums_uint64_t_0_8_uint8_t_8_9(_getOpaquePointer()));
+
+// CHECK: SWIFT_INLINE_THUNK swift::Array<C> F::getB() const {
+// CHECK-NEXT:    if (!isB()) abort();
+// CHECK-NEXT:    alignas(F) unsigned char buffer[sizeof(F)];
+// CHECK-NEXT:    auto *thisCopy = new(buffer) F(*this);
+// CHECK-NEXT:    char * _Nonnull payloadFromDestruction = thisCopy->_destructiveProjectEnumData();
+// CHECK-NEXT:    return swift::_impl::implClassFor<swift::Array<C>>::type::returnNewValue([&](char * _Nonnull result) SWIFT_INLINE_THUNK_ATTRIBUTES {
+// CHECK-NEXT:      swift::_impl::implClassFor<swift::Array<C>>::type::initializeWithTake(result, payloadFromDestruction);
+// CHECK-NEXT:    });
+// CHECK-NEXT:  }
+
+// CHECK:   SWIFT_INLINE_THUNK swift::Array<T_0_0> G<T_0_0>::getB() const {
+// CHECK-NEXT:     if (!isB()) abort();
+// CHECK-NEXT:     alignas(G) unsigned char buffer[sizeof(G)];
+// CHECK-NEXT:     auto *thisCopy = new(buffer) G(*this);
+// CHECK-NEXT:     char * _Nonnull payloadFromDestruction = thisCopy->_destructiveProjectEnumData();
+// CHECK-NEXT:     return swift::_impl::implClassFor<swift::Array<T_0_0>>::type::returnNewValue([&](char * _Nonnull result) SWIFT_INLINE_THUNK_ATTRIBUTES {
+// CHECK-NEXT:       swift::_impl::implClassFor<swift::Array<T_0_0>>::type::initializeWithTake(result, payloadFromDestruction);
+// CHECK-NEXT:     });
+// CHECK-NEXT:   }