Merge pull request #61053 from hyp/i/cxx-type-in-generic-ctx

[interop] use C++ value types bridged to Swift in Swift generic context from C++

Author: hyp

lib/PrintAsClang/ClangSyntaxPrinter.cpp

@@ -15,6 +15,9 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/SwiftNameTranslation.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclTemplate.h"
+#include "clang/AST/NestedNameSpecifier.h"
 
 using namespace swift;
 using namespace cxx_synthesis;
@@ -80,8 +83,35 @@ bool ClangSyntaxPrinter::printNominalTypeOutsideMemberDeclTemplateSpecifiers(
   return false;
 }
 
+void ClangSyntaxPrinter::printNominalClangTypeReference(
+    const clang::Decl *typeDecl) {
+  auto &clangCtx = typeDecl->getASTContext();
+  clang::PrintingPolicy pp(clangCtx.getLangOpts());
+  const auto *NS = clang::NestedNameSpecifier::getRequiredQualification(
+      clangCtx, clangCtx.getTranslationUnitDecl(),
+      typeDecl->getLexicalDeclContext());
+  if (NS)
+    NS->print(os, pp);
+  assert(cast<clang::NamedDecl>(typeDecl)->getDeclName().isIdentifier());
+  os << cast<clang::NamedDecl>(typeDecl)->getName();
+  if (auto *ctd = dyn_cast<clang::ClassTemplateSpecializationDecl>(typeDecl)) {
+    if (ctd->getTemplateArgs().size()) {
+      os << '<';
+      llvm::interleaveComma(ctd->getTemplateArgs().asArray(), os,
+                            [&](const clang::TemplateArgument &arg) {
+                              arg.print(pp, os, /*IncludeType=*/true);
+                            });
+      os << '>';
+    }
+  }
+}
+
 void ClangSyntaxPrinter::printNominalTypeReference(
     const NominalTypeDecl *typeDecl, const ModuleDecl *moduleContext) {
+  if (typeDecl->hasClangNode()) {
+    printNominalClangTypeReference(typeDecl->getClangDecl());
+    return;
+  }
   printModuleNamespaceQualifiersIfNeeded(typeDecl->getModuleContext(),
                                          moduleContext);
   // FIXME: Full qualifiers for nested types?

lib/PrintAsClang/ClangSyntaxPrinter.h

@@ -90,6 +90,9 @@ class ClangSyntaxPrinter {
   void printNominalTypeReference(const NominalTypeDecl *typeDecl,
                                  const ModuleDecl *moduleContext);
 
+  /// Print out the C++ record qualifier for the given C++ record.
+  void printNominalClangTypeReference(const clang::Decl *typeDecl);
+
   /// Print out the C++ class access qualifier for the given Swift  type
   /// declaration.
   ///

lib/PrintAsClang/DeclAndTypePrinter.h

@@ -72,6 +72,8 @@ class DeclAndTypePrinter {
         requiresExposedAttribute(requiresExposedAttribute),
         outputLang(outputLang) {}
 
+  SwiftToClangInteropContext &getInteropContext() { return interopContext; }
+
   /// Returns true if \p VD should be included in a compatibility header for
   /// the options the printer was constructed with.
   bool shouldInclude(const ValueDecl *VD);

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -18,6 +18,7 @@
 #include "PrimitiveTypeMapping.h"
 #include "PrintClangValueType.h"
 #include "PrintSwiftToClangCoreScaffold.h"
+#include "SwiftToClangInteropContext.h"
 
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/Module.h"
@@ -677,8 +678,14 @@ class ModuleWriter {
       }
       printer.printAdHocCategory(make_range(groupBegin, delayedMembers.end()));
     }
+
     // Print any out of line definitions.
     os << outOfLineDefinitionsOS.str();
+
+    // Print any additional metadata for referenced C++ types.
+    for (const auto *typeDecl :
+         printer.getInteropContext().getEmittedClangTypeDecls())
+      ClangValueTypePrinter::printClangTypeSwiftGenericTraits(os, typeDecl, &M);
   }
 };
 } // end anonymous namespace

lib/PrintAsClang/PrintClangClassType.cpp

@@ -95,7 +95,8 @@ void ClangClassTypePrinter::printClassTypeDecl(
       });
 
   ClangValueTypePrinter::printTypeGenericTraits(
-      os, typeDecl, typeMetadataFuncName, /*genericRequirements=*/{});
+      os, typeDecl, typeMetadataFuncName, /*genericRequirements=*/{},
+      typeDecl->getModuleContext());
 }
 
 void ClangClassTypePrinter::printClassTypeReturnScaffold(

lib/PrintAsClang/PrintClangFunction.cpp

@@ -28,8 +28,6 @@
 #include "swift/ClangImporter/ClangImporter.h"
 #include "swift/IRGen/IRABIDetailsProvider.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/AST/DeclTemplate.h"
-#include "clang/AST/NestedNameSpecifier.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace swift;
@@ -108,26 +106,14 @@ class ClangTypeHandler {
   }
 
   void printTypeName(raw_ostream &os) const {
-    auto &clangCtx = typeDecl->getASTContext();
-    clang::PrintingPolicy pp(clangCtx.getLangOpts());
-    const auto *NS = clang::NestedNameSpecifier::getRequiredQualification(
-        clangCtx, clangCtx.getTranslationUnitDecl(),
-        typeDecl->getLexicalDeclContext());
-    if (NS)
-      NS->print(os, pp);
-    assert(cast<clang::NamedDecl>(typeDecl)->getDeclName().isIdentifier());
-    os << cast<clang::NamedDecl>(typeDecl)->getName();
-    if (auto *ctd =
-            dyn_cast<clang::ClassTemplateSpecializationDecl>(typeDecl)) {
-      if (ctd->getTemplateArgs().size()) {
-        os << '<';
-        llvm::interleaveComma(ctd->getTemplateArgs().asArray(), os,
-                              [&](const clang::TemplateArgument &arg) {
-                                arg.print(pp, os, /*IncludeType=*/true);
-                              });
-        os << '>';
-      }
-    }
+    ClangSyntaxPrinter(os).printNominalClangTypeReference(typeDecl);
+  }
+
+  static void
+  printGenericReturnScaffold(raw_ostream &os, StringRef templateParamName,
+                             llvm::function_ref<void(StringRef)> bodyOfReturn) {
+    printReturnScaffold(nullptr, os, templateParamName, templateParamName,
+                        bodyOfReturn);
   }
 
   void printReturnScaffold(raw_ostream &os,
@@ -140,14 +126,22 @@ class ClangTypeHandler {
       llvm::raw_string_ostream unqualTypeNameOS(typeName);
       unqualTypeNameOS << cast<clang::NamedDecl>(typeDecl)->getName();
     }
+    printReturnScaffold(typeDecl, os, fullQualifiedType, typeName,
+                        bodyOfReturn);
+  }
+
+private:
+  static void
+  printReturnScaffold(const clang::Decl *typeDecl, raw_ostream &os,
+                      StringRef fullQualifiedType, StringRef typeName,
+                      llvm::function_ref<void(StringRef)> bodyOfReturn) {
     os << "alignas(alignof(" << fullQualifiedType << ")) char storage[sizeof("
        << fullQualifiedType << ")];\n";
     os << "auto * _Nonnull storageObjectPtr = reinterpret_cast<"
        << fullQualifiedType << " *>(storage);\n";
     bodyOfReturn("storage");
     os << ";\n";
-    auto *cxxRecord = cast<clang::CXXRecordDecl>(typeDecl);
-    if (cxxRecord->isTrivial()) {
+    if (typeDecl && cast<clang::CXXRecordDecl>(typeDecl)->isTrivial()) {
       // Trivial object can be just copied and not destroyed.
       os << "return *storageObjectPtr;\n";
       return;
@@ -157,7 +151,6 @@ class ClangTypeHandler {
     os << "return result;\n";
   }
 
-private:
   const clang::Decl *typeDecl;
 };
 
@@ -316,6 +309,7 @@ class CFunctionSignatureTypePrinter
       handler.printTypeName(os);
       if (typeUseKind == FunctionSignatureTypeUse::ParamType)
         os << '&';
+      interopContext.recordEmittedClangTypeDecl(decl);
       return ClangRepresentation::representable;
     }
 
@@ -1019,6 +1013,11 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
          << ">::type::returnNewValue([&](void * _Nonnull returnValue) {\n";
       printCallToCFunc(/*additionalParam=*/StringRef("returnValue"));
       os << ";\n  });\n";
+      os << "  } else if constexpr (::swift::"
+         << cxx_synthesis::getCxxImplNamespaceName()
+         << "::isSwiftBridgedCxxRecord<" << resultTyName << ">) {\n";
+      ClangTypeHandler::printGenericReturnScaffold(os, resultTyName,
+                                                   printCallToCFunc);
       os << "  } else {\n";
       os << "  " << resultTyName << " returnValue;\n";
       printCallToCFunc(/*additionalParam=*/StringRef(ros.str()));

lib/PrintAsClang/PrintClangValueType.cpp

@@ -406,7 +406,8 @@ void ClangValueTypePrinter::printValueTypeDecl(
     printCValueTypeStorageStruct(cPrologueOS, typeDecl, *typeSizeAlign);
 
   printTypeGenericTraits(os, typeDecl, typeMetadataFuncName,
-                         typeMetadataFuncGenericParams);
+                         typeMetadataFuncGenericParams,
+                         typeDecl->getModuleContext());
 }
 
 void ClangValueTypePrinter::printParameterCxxToCUseScaffold(
@@ -456,24 +457,47 @@ void ClangValueTypePrinter::printValueTypeReturnScaffold(
   os << "  });\n";
 }
 
+void ClangValueTypePrinter::printClangTypeSwiftGenericTraits(
+    raw_ostream &os, const NominalTypeDecl *typeDecl,
+    const ModuleDecl *moduleContext) {
+  assert(typeDecl->hasClangNode());
+  // Do not reference unspecialized templates.
+  if (isa<clang::ClassTemplateDecl>(typeDecl->getClangDecl()))
+    return;
+  auto typeMetadataFunc = irgen::LinkEntity::forTypeMetadataAccessFunction(
+      typeDecl->getDeclaredType()->getCanonicalType());
+  std::string typeMetadataFuncName = typeMetadataFunc.mangleAsString();
+  printTypeGenericTraits(os, typeDecl, typeMetadataFuncName,
+                         /*typeMetadataFuncRequirements=*/{}, moduleContext);
+}
+
 void ClangValueTypePrinter::printTypeGenericTraits(
     raw_ostream &os, const NominalTypeDecl *typeDecl,
     StringRef typeMetadataFuncName,
-    ArrayRef<GenericRequirement> typeMetadataFuncRequirements) {
+    ArrayRef<GenericRequirement> typeMetadataFuncRequirements,
+    const ModuleDecl *moduleContext) {
   ClangSyntaxPrinter printer(os);
   // FIXME: avoid popping out of the module's namespace here.
   os << "} // end namespace \n\n";
   os << "namespace swift {\n";
 
+  if (typeDecl->hasClangNode()) {
+    /// Print a reference to the type metadata fucntion for a C++ type.
+    ClangSyntaxPrinter(os).printNamespace(
+        cxx_synthesis::getCxxImplNamespaceName(), [&](raw_ostream &os) {
+          ClangSyntaxPrinter(os).printCTypeMetadataTypeFunction(
+              typeDecl, typeMetadataFuncName, typeMetadataFuncRequirements);
+        });
+  }
+
   os << "#pragma clang diagnostic push\n";
   os << "#pragma clang diagnostic ignored \"-Wc++17-extensions\"\n";
   if (typeMetadataFuncRequirements.empty()) {
     // FIXME: generic type support.
     os << "template<>\n";
     os << "static inline const constexpr bool isUsableInGenericContext<";
-    printer.printBaseName(typeDecl->getModuleContext());
-    os << "::";
-    printer.printBaseName(typeDecl);
+    printer.printNominalTypeReference(typeDecl,
+                                      /*moduleContext=*/nullptr);
     os << "> = true;\n";
   }
   if (printer.printNominalTypeOutsideMemberDeclTemplateSpecifiers(typeDecl))
@@ -484,16 +508,27 @@ void ClangValueTypePrinter::printTypeGenericTraits(
   os << "> {\n";
   os << "  static inline void * _Nonnull getTypeMetadata() {\n";
   os << "    return ";
-  printer.printBaseName(typeDecl->getModuleContext());
-  os << "::" << cxx_synthesis::getCxxImplNamespaceName() << "::";
+  if (!typeDecl->hasClangNode()) {
+    printer.printBaseName(typeDecl->getModuleContext());
+    os << "::";
+  }
+  os << cxx_synthesis::getCxxImplNamespaceName() << "::";
   ClangSyntaxPrinter(os).printSwiftTypeMetadataAccessFunctionCall(
       typeMetadataFuncName, typeMetadataFuncRequirements);
   os << "._0;\n";
   os << "  }\n};\n";
 
   os << "namespace " << cxx_synthesis::getCxxImplNamespaceName() << "{\n";
 
-  if (!isa<ClassDecl>(typeDecl) && typeMetadataFuncRequirements.empty()) {
+  if (typeDecl->hasClangNode()) {
+    os << "template<>\n";
+    os << "static inline const constexpr bool isSwiftBridgedCxxRecord<";
+    printer.printNominalClangTypeReference(typeDecl->getClangDecl());
+    os << "> = true;\n";
+  }
+
+  if (!isa<ClassDecl>(typeDecl) && !typeDecl->hasClangNode() &&
+      typeMetadataFuncRequirements.empty()) {
     // FIXME: generic support.
     os << "template<>\n";
     os << "static inline const constexpr bool isValueType<";
@@ -512,7 +547,7 @@ void ClangValueTypePrinter::printTypeGenericTraits(
   }
 
   // FIXME: generic support.
-  if (typeMetadataFuncRequirements.empty()) {
+  if (!typeDecl->hasClangNode() && typeMetadataFuncRequirements.empty()) {
     os << "template<>\n";
     os << "struct implClassFor<";
     printer.printBaseName(typeDecl->getModuleContext());
@@ -528,6 +563,6 @@ void ClangValueTypePrinter::printTypeGenericTraits(
   os << "#pragma clang diagnostic pop\n";
   os << "} // namespace swift\n";
   os << "\nnamespace ";
-  printer.printBaseName(typeDecl->getModuleContext());
+  printer.printBaseName(moduleContext);
   os << " {\n";
 }

lib/PrintAsClang/PrintClangValueType.h

@@ -93,10 +93,17 @@ class ClangValueTypePrinter {
   static void printTypeGenericTraits(
       raw_ostream &os, const NominalTypeDecl *typeDecl,
       StringRef typeMetadataFuncName,
-      ArrayRef<GenericRequirement> typeMetadataFuncRequirements);
+      ArrayRef<GenericRequirement> typeMetadataFuncRequirements,
+      const ModuleDecl *moduleContext);
 
   static void forwardDeclType(raw_ostream &os, const NominalTypeDecl *typeDecl);
 
+  /// Print out the type traits that allow a C++ type be used a Swift generic
+  /// context.
+  static void printClangTypeSwiftGenericTraits(raw_ostream &os,
+                                               const NominalTypeDecl *typeDecl,
+                                               const ModuleDecl *moduleContext);
+
 private:
   raw_ostream &os;
   raw_ostream &cPrologueOS;

lib/PrintAsClang/SwiftToClangInteropContext.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "SwiftToClangInteropContext.h"
+#include "swift/AST/Decl.h"
 #include "swift/IRGen/IRABIDetailsProvider.h"
 
 using namespace swift;
@@ -33,3 +34,9 @@ void SwiftToClangInteropContext::runIfStubForDeclNotEmitted(
   if (result.second)
     function();
 }
+
+void SwiftToClangInteropContext::recordEmittedClangTypeDecl(
+    const NominalTypeDecl *typeDecl) {
+  assert(typeDecl->hasClangNode());
+  referencedClangTypeDecls.insert(typeDecl);
+}

lib/PrintAsClang/SwiftToClangInteropContext.h

@@ -13,7 +13,9 @@
 #ifndef SWIFT_PRINTASCLANG_SWIFTTOCLANGINTEROPCONTEXT_H
 #define SWIFT_PRINTASCLANG_SWIFTTOCLANGINTEROPCONTEXT_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringSet.h"
 #include <memory>
 
@@ -23,6 +25,7 @@ class Decl;
 class IRABIDetailsProvider;
 class IRGenOptions;
 class ModuleDecl;
+class NominalTypeDecl;
 
 /// The \c SwiftToClangInteropContext class is responsible for providing
 /// access to the other required subsystems of the compiler during the emission
@@ -40,11 +43,21 @@ class SwiftToClangInteropContext {
   void runIfStubForDeclNotEmitted(llvm::StringRef stubName,
                                   llvm::function_ref<void(void)> function);
 
+  /// Records that the given nominal type decl that has a clang declaration was
+  /// emitted in the generated header.
+  void recordEmittedClangTypeDecl(const NominalTypeDecl *typeDecl);
+
+  inline const llvm::SetVector<const NominalTypeDecl *> &
+  getEmittedClangTypeDecls() const {
+    return referencedClangTypeDecls;
+  }
+
 private:
   ModuleDecl &mod;
   const IRGenOptions &irGenOpts;
   std::unique_ptr<IRABIDetailsProvider> irABIDetails;
   llvm::StringSet<> emittedStubs;
+  llvm::SetVector<const NominalTypeDecl *> referencedClangTypeDecls;
 };
 
 } // end namespace swift

stdlib/public/SwiftShims/_SwiftCxxInteroperability.h

@@ -160,6 +160,11 @@ template <class T> static inline const constexpr bool isValueType = false;
 /// boxed.
 template <class T> static inline const constexpr bool isOpaqueLayout = false;
 
+/// True if the given type is a C++ record that was bridged to Swift, giving
+/// Swift ability to work with it in a generic context.
+template <class T>
+static inline const constexpr bool isSwiftBridgedCxxRecord = false;
+
 /// Returns the opaque pointer to the given value.
 template <class T>
 inline const void *_Nonnull getOpaquePointer(const T &value) {