[interop][SwiftToCxx] bridge returned C++ record types back to C++ from Swift

Author: hyp

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -26,6 +26,7 @@
 #include "swift/AST/SwiftNameTranslation.h"
 #include "swift/AST/TypeDeclFinder.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include "swift/Strings.h"
 
 #include "clang/AST/Decl.h"
 #include "clang/Basic/Module.h"
@@ -178,6 +179,14 @@ class ModuleWriter {
       }
     }
 
+    if (outputLangMode == OutputLanguageMode::Cxx) {
+      // Only add C++ imports in C++ mode for now.
+      if (!D->hasClangNode())
+        return true;
+      if (otherModule->getName().str() == CLANG_HEADER_MODULE_NAME)
+        return true;
+    }
+
     imports.insert(otherModule);
     return true;
   }
@@ -258,8 +267,10 @@ class ModuleWriter {
     if (outputLangMode == OutputLanguageMode::Cxx) {
       if (isa<StructDecl>(TD) || isa<EnumDecl>(TD)) {
         auto *NTD = cast<NominalTypeDecl>(TD);
-        forwardDeclare(
-            NTD, [&]() { ClangValueTypePrinter::forwardDeclType(os, NTD); });
+        if (!addImport(NTD)) {
+          forwardDeclare(
+              NTD, [&]() { ClangValueTypePrinter::forwardDeclType(os, NTD); });
+        }
       }
       return;
     }

lib/PrintAsClang/PrintAsClang.cpp

@@ -395,8 +395,11 @@ static int compareImportModulesByName(const ImportModuleTy *left,
 
 static void writeImports(raw_ostream &out,
                          llvm::SmallPtrSetImpl<ImportModuleTy> &imports,
-                         ModuleDecl &M, StringRef bridgingHeader) {
-  out << "#if __has_feature(modules)\n";
+                         ModuleDecl &M, StringRef bridgingHeader,
+                         bool useCxxImport = false) {
+  // Note: we can't use has_feature(modules) as it's always enabled in C++20
+  // mode.
+  out << "#if __has_feature(objc_modules)\n";
 
   out << "#if __has_warning(\"-Watimport-in-framework-header\")\n"
       << "#pragma clang diagnostic ignored \"-Watimport-in-framework-header\"\n"
@@ -420,6 +423,8 @@ static void writeImports(raw_ostream &out,
   // Track printed names to handle overlay modules.
   llvm::SmallPtrSet<Identifier, 8> seenImports;
   bool includeUnderlying = false;
+  StringRef importDirective =
+      useCxxImport ? "#pragma clang module import" : "@import";
   for (auto import : sortedImports) {
     if (auto *swiftModule = import.dyn_cast<ModuleDecl *>()) {
       auto Name = swiftModule->getName();
@@ -428,12 +433,12 @@ static void writeImports(raw_ostream &out,
         continue;
       }
       if (seenImports.insert(Name).second)
-        out << "@import " << Name.str() << ";\n";
+        out << importDirective << ' ' << Name.str() << ";\n";
     } else {
       const auto *clangModule = import.get<const clang::Module *>();
       assert(clangModule->isSubModule() &&
              "top-level modules should use a normal swift::ModuleDecl");
-      out << "@import ";
+      out << importDirective << ' ';
       ModuleDecl::ReverseFullNameIterator(clangModule).printForward(out);
       out << ";\n";
     }
@@ -489,16 +494,14 @@ static std::string computeMacroGuard(const ModuleDecl *M) {
   return (llvm::Twine(M->getNameStr().upper()) + "_SWIFT_H").str();
 }
 
-static std::string
-getModuleContentsCxxString(ModuleDecl &M,
-                           SwiftToClangInteropContext &interopContext,
-                           bool requiresExposedAttribute) {
-  SmallPtrSet<ImportModuleTy, 8> imports;
+static std::string getModuleContentsCxxString(
+    ModuleDecl &M, SmallPtrSet<ImportModuleTy, 8> &imports,
+    SwiftToClangInteropContext &interopContext, bool requiresExposedAttribute) {
   std::string moduleContentsBuf;
   llvm::raw_string_ostream moduleContents{moduleContentsBuf};
   printModuleContentsAsCxx(moduleContents, imports, M, interopContext,
                            requiresExposedAttribute);
-  return moduleContents.str();
+  return std::move(moduleContents.str());
 }
 
 bool swift::printAsClangHeader(raw_ostream &os, ModuleDecl *M,
@@ -522,9 +525,13 @@ bool swift::printAsClangHeader(raw_ostream &os, ModuleDecl *M,
     // FIXME: Expose Swift with @expose by default.
     if (ExposePublicDeclsInClangHeader ||
         M->DeclContext::getASTContext().LangOpts.EnableCXXInterop) {
-      os << getModuleContentsCxxString(
-          *M, interopContext,
+      SmallPtrSet<ImportModuleTy, 8> imports;
+      auto contents = getModuleContentsCxxString(
+          *M, imports, interopContext,
           /*requiresExposedAttribute=*/!ExposePublicDeclsInClangHeader);
+      // FIXME: In ObjC++ mode, we do not need to reimport duplicate modules.
+      writeImports(os, imports, *M, bridgingHeader, /*useCxxImport=*/true);
+      os << contents;
     }
   });
   writeEpilogue(os);

lib/PrintAsClang/PrintClangFunction.cpp

@@ -27,6 +27,9 @@
 #include "swift/AST/TypeVisitor.h"
 #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;
@@ -90,6 +93,74 @@ struct CFunctionSignatureTypePrinterModifierDelegate {
       mapValueTypeUseKind = None;
 };
 
+class ClangTypeHandler {
+public:
+  ClangTypeHandler(const clang::Decl *typeDecl) : typeDecl(typeDecl) {}
+
+  bool isRepresentable() const {
+    // We can only return trivial types, or
+    // types that can be moved or copied.
+    if (auto *record = dyn_cast<clang::CXXRecordDecl>(typeDecl)) {
+      return record->isTrivial() || record->hasMoveConstructor() ||
+             record->hasCopyConstructorWithConstParam();
+    }
+    return false;
+  }
+
+  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 << '>';
+      }
+    }
+  }
+
+  void printReturnScaffold(raw_ostream &os,
+                           llvm::function_ref<void(StringRef)> bodyOfReturn) {
+    std::string fullQualifiedType;
+    std::string typeName;
+    {
+      llvm::raw_string_ostream typeNameOS(fullQualifiedType);
+      printTypeName(typeNameOS);
+      llvm::raw_string_ostream unqualTypeNameOS(typeName);
+      unqualTypeNameOS << cast<clang::NamedDecl>(typeDecl)->getName();
+    }
+    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()) {
+      // Trivial object can be just copied and not destroyed.
+      os << "return *storageObjectPtr;\n";
+      return;
+    }
+    os << fullQualifiedType << " result(std::move(*storageObjectPtr));\n";
+    os << "storageObjectPtr->~" << typeName << "();\n";
+    os << "return result;\n";
+  }
+
+private:
+  const clang::Decl *typeDecl;
+};
+
 // Prints types in the C function signature that corresponds to the
 // native Swift function/method.
 class CFunctionSignatureTypePrinter
@@ -235,6 +306,14 @@ class CFunctionSignatureTypePrinter
     if (languageMode != OutputLanguageMode::Cxx)
       return ClangRepresentation::unsupported;
 
+    if (decl->hasClangNode()) {
+      ClangTypeHandler handler(decl->getClangDecl());
+      if (!handler.isRepresentable())
+        return ClangRepresentation::unsupported;
+      handler.printTypeName(os);
+      return ClangRepresentation::representable;
+    }
+
     // FIXME: Handle optional structures.
     if (typeUseKind == FunctionSignatureTypeUse::ParamType) {
       if (!isInOutParam) {
@@ -938,24 +1017,31 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
       return;
     }
     if (auto *decl = resultTy->getNominalOrBoundGenericNominal()) {
+      auto valueTypeReturnThunker = [&](StringRef resultPointerName) {
+        if (auto directResultType = signature.getDirectResultType()) {
+          std::string typeEncoding =
+              encodeTypeInfo(*directResultType, moduleContext, typeMapping);
+          os << cxx_synthesis::getCxxImplNamespaceName()
+             << "::swift_interop_returnDirect_" << typeEncoding << '('
+             << resultPointerName << ", ";
+          printCallToCFunc(None);
+          os << ')';
+        } else {
+          printCallToCFunc(/*firstParam=*/resultPointerName);
+        }
+      };
+      if (decl->hasClangNode()) {
+        ClangTypeHandler handler(decl->getClangDecl());
+        assert(handler.isRepresentable());
+        handler.printReturnScaffold(os, valueTypeReturnThunker);
+        return;
+      }
       ClangValueTypePrinter valueTypePrinter(os, cPrologueOS, interopContext);
 
       valueTypePrinter.printValueTypeReturnScaffold(
           decl, moduleContext,
           [&]() { printTypeImplTypeSpecifier(resultTy, moduleContext); },
-          [&](StringRef resultPointerName) {
-            if (auto directResultType = signature.getDirectResultType()) {
-              std::string typeEncoding =
-                  encodeTypeInfo(*directResultType, moduleContext, typeMapping);
-              os << cxx_synthesis::getCxxImplNamespaceName()
-                 << "::swift_interop_returnDirect_" << typeEncoding << '('
-                 << resultPointerName << ", ";
-              printCallToCFunc(None);
-              os << ')';
-            } else {
-              printCallToCFunc(/*firstParam=*/resultPointerName);
-            }
-          });
+          valueTypeReturnThunker);
       return;
     }
   }

test/Interop/CxxToSwiftToCxx/bridge-cxx-struct-back-to-cxx-execution.cpp

@@ -0,0 +1,79 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend -typecheck %t/use-cxx-types.swift -typecheck -module-name UseCxx -emit-clang-header-path %t/UseCxx.h -I %t -enable-experimental-cxx-interop -clang-header-expose-public-decls
+
+// RUN: %target-interop-build-clangxx -c %t/use-swift-cxx-types.cpp -I %t -o %t/swift-cxx-execution.o -g
+// RUN: %target-interop-build-swift %t/use-cxx-types.swift -o %t/swift-cxx-execution -Xlinker %t/swift-cxx-execution.o -module-name UseCxx -Xfrontend -entry-point-function-name -Xfrontend swiftMain -I %t -g
+
+// RUN: %target-codesign %t/swift-cxx-execution
+// RUN: %target-run %t/swift-cxx-execution | %FileCheck %s
+
+// REQUIRES: executable_test
+
+//--- header.h
+
+extern "C" void puts(const char *);
+
+struct Trivial {
+    int x, y;
+
+    inline Trivial(int x, int y) : x(x), y(y) {}
+};
+
+template<class T>
+struct NonTrivialTemplate {
+    T x;
+
+    inline NonTrivialTemplate(T x) : x(x) {
+        puts("create NonTrivialTemplate");
+    }
+    inline NonTrivialTemplate(const NonTrivialTemplate<T> &) = default;
+    inline NonTrivialTemplate(NonTrivialTemplate<T> &&other) : x(static_cast<T &&>(other.x)) {
+        puts("move NonTrivialTemplate");
+    }
+    inline ~NonTrivialTemplate() {
+        puts("~NonTrivialTemplate");
+    }
+};
+
+//--- module.modulemap
+module CxxTest {
+    header "header.h"
+    requires cplusplus
+}
+
+//--- use-cxx-types.swift
+import CxxTest
+
+public func retNonTrivial(y: CInt) -> NonTrivialTemplate<Trivial> {
+    return NonTrivialTemplate<Trivial>(Trivial(42, y))
+}
+
+public func retTrivial(_ x: CInt) -> Trivial {
+    return Trivial(x, -x)
+}
+
+//--- use-swift-cxx-types.cpp
+
+#include "header.h"
+#include "UseCxx.h"
+#include <assert.h>
+
+int main() {
+  {
+    auto x = UseCxx::retTrivial(423421);
+    assert(x.x == 423421);
+    assert(x.y == -423421);
+  }
+  {
+    auto x = UseCxx::retNonTrivial(-942);
+    assert(x.x.y == -942);
+    assert(x.x.x == 42);
+  }
+// CHECK: create NonTrivialTemplate
+// CHECK-NEXT: move NonTrivialTemplate
+// CHECK-NEXT: ~NonTrivialTemplate
+// CHECK-NEXT: ~NonTrivialTemplate
+  return 0;
+}