[interop] Swift -> C++ -> Swift class type bridging

Author: hyp

include/swift/ClangImporter/ClangImporterRequests.h

@@ -311,7 +311,9 @@ enum class CxxRecordSemanticsKind {
   // A record that is either not copyable or not destructible.
   MissingLifetimeOperation,
   // A record that contains a pointer (aka non-trivial type).
-  UnsafePointerMember
+  UnsafePointerMember,
+  // A C++ record that represents a Swift class type exposed to C++ from Swift.
+  SwiftClassType
 };
 
 struct CxxRecordSemanticsDescriptor final {
@@ -366,6 +368,23 @@ class CxxRecordSemantics
                                   CxxRecordSemanticsDescriptor) const;
 };
 
+/// Does this C++ record represent a Swift type.
+class CxxRecordAsSwiftType
+    : public SimpleRequest<CxxRecordAsSwiftType,
+                           ValueDecl *(CxxRecordSemanticsDescriptor),
+                           RequestFlags::Uncached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+  // Source location
+  SourceLoc getNearestLoc() const { return SourceLoc(); };
+
+private:
+  friend SimpleRequest;
+
+  ValueDecl *evaluate(Evaluator &evaluator, CxxRecordSemanticsDescriptor) const;
+};
+
 struct SafeUseOfCxxDeclDescriptor final {
   const clang::Decl *decl;
   ASTContext &ctx;

include/swift/ClangImporter/ClangImporterTypeIDZone.def

@@ -33,6 +33,9 @@ SWIFT_REQUEST(ClangImporter, ObjCInterfaceAndImplementationRequest,
 SWIFT_REQUEST(ClangImporter, CxxRecordSemantics,
               CxxRecordSemanticsKind(const clang::CXXRecordDecl *), Cached,
               NoLocationInfo)
+SWIFT_REQUEST(ClangImporter, CxxRecordAsSwiftType,
+              ValueDecl *(CxxRecordSemanticsDescriptor), Cached,
+              NoLocationInfo)
 SWIFT_REQUEST(ClangImporter, IsSafeUseOfCxxDecl,
               bool(SafeUseOfCxxRecordDescriptor), Cached,
               NoLocationInfo)

lib/ClangImporter/ClangImporter.cpp

@@ -6498,6 +6498,29 @@ static bool hasRequiredValueTypeOperations(const clang::CXXRecordDecl *decl) {
   return true;
 }
 
+static bool isSwiftClassType(const clang::CXXRecordDecl *decl) {
+  // Swift type must be annotated with external_source_symbol attribute.
+  auto essAttr = decl->getAttr<clang::ExternalSourceSymbolAttr>();
+  if (!essAttr || essAttr->getLanguage() != "Swift" ||
+      essAttr->getDefinedIn().empty() || essAttr->getUSR().empty())
+    return false;
+
+  // Ensure that the baseclass is swift::RefCountedClass.
+  auto baseDecl = decl;
+  do {
+    if (baseDecl->getNumBases() != 1)
+      return false;
+    auto baseClassSpecifier = *baseDecl->bases_begin();
+    auto Ty = baseClassSpecifier.getType();
+    auto nextBaseDecl = Ty->getAsCXXRecordDecl();
+    if (!nextBaseDecl)
+      return false;
+    baseDecl = nextBaseDecl;
+  } while (baseDecl->getName() != "RefCountedClass");
+
+  return true;
+}
+
 CxxRecordSemanticsKind
 CxxRecordSemantics::evaluate(Evaluator &evaluator,
                              CxxRecordSemanticsDescriptor desc) const {
@@ -6512,6 +6535,9 @@ CxxRecordSemantics::evaluate(Evaluator &evaluator,
     return CxxRecordSemanticsKind::Trivial;
   }
 
+  if (isSwiftClassType(cxxDecl))
+    return CxxRecordSemanticsKind::SwiftClassType;
+
   if (!hasRequiredValueTypeOperations(cxxDecl)) {
     if (hasUnsafeAPIAttr(cxxDecl))
       desc.ctx.Diags.diagnose({}, diag::api_pattern_attr_ignored,
@@ -6549,6 +6575,34 @@ CxxRecordSemantics::evaluate(Evaluator &evaluator,
   return CxxRecordSemanticsKind::Owned;
 }
 
+ValueDecl *
+CxxRecordAsSwiftType::evaluate(Evaluator &evaluator,
+                               CxxRecordSemanticsDescriptor desc) const {
+  auto cxxDecl = dyn_cast<clang::CXXRecordDecl>(desc.decl);
+  if (!cxxDecl)
+    return nullptr;
+  if (!isSwiftClassType(cxxDecl))
+    return nullptr;
+
+  SmallVector<ValueDecl *, 1> results;
+  auto *essaAttr = cxxDecl->getAttr<clang::ExternalSourceSymbolAttr>();
+  auto *mod = desc.ctx.getModuleByName(essaAttr->getDefinedIn());
+  if (!mod) {
+    // TODO: warn about missing 'import'.
+    return nullptr;
+  }
+  // FIXME: Support renamed declarations.
+  auto swiftName = cxxDecl->getName();
+  // FIXME: handle nested Swift types once they're supported.
+  mod->lookupValue(desc.ctx.getIdentifier(swiftName), NLKind::UnqualifiedLookup,
+                   results);
+  if (results.size() == 1) {
+    if (dyn_cast<ClassDecl>(results[0]))
+      return results[0];
+  }
+  return nullptr;
+}
+
 bool IsSafeUseOfCxxDecl::evaluate(Evaluator &evaluator,
                                   SafeUseOfCxxDeclDescriptor desc) const {
   const clang::Decl *decl = desc.decl;
@@ -6577,6 +6631,8 @@ bool IsSafeUseOfCxxDecl::evaluate(Evaluator &evaluator,
             method->getReturnType().getCanonicalType())) {
       if (auto cxxRecordReturnType =
               dyn_cast<clang::CXXRecordDecl>(returnType->getDecl())) {
+        if (isSwiftClassType(cxxRecordReturnType))
+          return true;
         if (hasIteratorAPIAttr(cxxRecordReturnType) ||
             isIterator(cxxRecordReturnType)) {
           return false;

lib/ClangImporter/ImportDecl.cpp

@@ -2624,6 +2624,11 @@ namespace {
             decl->getLocation());
         return nullptr;
       }
+      if (semanticsKind == CxxRecordSemanticsKind::SwiftClassType) {
+        // FIXME: add a diagnostic here for unsupported imported use of Swift
+        // type?
+        return nullptr;
+      }
 
       auto result = VisitRecordDecl(decl);
       if (!result)

lib/ClangImporter/ImportType.cpp

@@ -32,8 +32,9 @@
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/Type.h"
-#include "swift/AST/Types.h"
 #include "swift/AST/TypeVisitor.h"
+#include "swift/AST/Types.h"
+#include "swift/ClangImporter/ClangImporterRequests.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/Parse/Token.h"
 #include "swift/Strings.h"
@@ -2142,6 +2143,20 @@ ImportedType ClangImporter::Implementation::importFunctionReturnType(
     }
   }
 
+  // Import the underlying result type.
+  if (clangDecl) {
+    if (auto recordType = returnType->getAsCXXRecordDecl()) {
+      if (auto *vd = evaluateOrDefault(
+              SwiftContext.evaluator,
+              CxxRecordAsSwiftType({recordType, SwiftContext}), nullptr)) {
+        if (auto *cd = dyn_cast<ClassDecl>(vd)) {
+          Type t = ClassType::get(cd, Type(), SwiftContext);
+          return ImportedType(t, /*implicitlyUnwraps=*/false);
+        }
+      }
+    }
+  }
+
   // Import the result type.
   return importType(returnType,
                     (isAuditedResult ? ImportTypeKind::AuditedResult
@@ -2358,6 +2373,21 @@ ClangImporter::Implementation::importParameterType(
         optionalityOfParam == OTK_ImplicitlyUnwrappedOptional;
   }
 
+  if (!swiftParamTy) {
+    if (auto recordType = paramTy->getAsCXXRecordDecl()) {
+
+      if (auto *vd = evaluateOrDefault(
+              SwiftContext.evaluator,
+              CxxRecordAsSwiftType({recordType, SwiftContext}), nullptr)) {
+
+        if (auto *cd = dyn_cast<ClassDecl>(vd)) {
+
+          swiftParamTy = ClassType::get(cd, Type(), SwiftContext);
+        }
+      }
+    }
+  }
+
   if (!swiftParamTy) {
     bool sendableByDefault =
         paramIsCompletionHandler &&

lib/SIL/IR/SILFunctionType.cpp

@@ -1433,6 +1433,20 @@ static bool isFormallyPassedIndirectly(TypeConverter &TC,
                                        AbstractionPattern origType,
                                        CanType substType,
                                        const TypeLowering &substTL) {
+  // If this is a native Swift class that's passed directly to C/C++, treat it
+  // as indirect.
+  if (origType.isClangType()) {
+    if (auto *classDecl = substType->lookThroughAllOptionalTypes()
+                              ->getClassOrBoundGenericClass()) {
+      if (!classDecl->isForeignReferenceType()) {
+        if (origType.getClangType()
+                ->getUnqualifiedDesugaredType()
+                ->getAsCXXRecordDecl())
+          return true;
+      }
+    }
+  }
+
   // If the C type of the argument is a const pointer, but the Swift type
   // isn't, treat it as indirect.
   if (origType.isClangType()
@@ -3301,6 +3315,23 @@ class CFunctionTypeConventions : public Conventions {
   ParameterConvention getIndirectParameter(unsigned index,
                             const AbstractionPattern &type,
                            const TypeLowering &substTL) const override {
+    if (type.isClangType()) {
+      if (type.getClangType()
+              ->getUnqualifiedDesugaredType()
+              ->getAsCXXRecordDecl()) {
+        auto t = substTL.getLoweredType().getASTType();
+        if (auto *classDecl = t.getPointer()
+                                  ->lookThroughAllOptionalTypes()
+                                  ->getClassOrBoundGenericClass()) {
+          if (!classDecl->isForeignReferenceType()) {
+            assert(!classDecl->hasClangNode() &&
+                   "unexpected imported class type in C function");
+            assert(!classDecl->isGeneric());
+            return ParameterConvention::Indirect_In_Guaranteed;
+          }
+        }
+      }
+    }
     return getIndirectCParameterConvention(getParamType(index));
   }
 
@@ -3328,6 +3359,20 @@ class CFunctionTypeConventions : public Conventions {
       return ResultConvention::Owned;
     if (tl.getLoweredType().isForeignReferenceType())
       return ResultConvention::Unowned;
+    if (FnType->getReturnType()
+            ->getUnqualifiedDesugaredType()
+            ->getAsCXXRecordDecl()) {
+      auto t = tl.getLoweredType().getASTType();
+      if (auto *classDecl = t.getPointer()
+                                ->lookThroughAllOptionalTypes()
+                                ->getClassOrBoundGenericClass()) {
+        assert(!classDecl->hasClangNode() &&
+               "unexpected imported class type in C function");
+        assert(!classDecl->isGeneric());
+        return ResultConvention::Owned;
+      }
+    }
+
     return ResultConvention::Autoreleased;
   }
 

test/Interop/SwiftToCxxToSwift/import-swift-class-back-to-swift-execution.swift

@@ -0,0 +1,114 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend -typecheck %t/swiftMod.swift -typecheck -module-name SwiftMod -emit-clang-header-path %t/swiftMod.h -I %t -enable-experimental-cxx-interop -Xcc -DFIRSTPASS
+
+// RUN: %target-interop-build-swift %t/swiftMod.swift -o %t/swift-execution -module-name SwiftMod -I %t -g -DSECOND_PASS -Xcc -DSWIFT_CXX_INTEROP_HIDE_SWIFT_ERROR
+
+// RUN: %target-codesign %t/swift-execution
+// RUN: %target-run %t/swift-execution | %FileCheck %s
+
+// REQUIRES: executable_test
+
+//--- header.h
+#ifndef FIRSTPASS
+
+#include "swiftMod.h"
+
+inline SwiftMod::ExposedToCxx createSwiftClassInCxx() {
+    return SwiftMod::ExposedToCxx::init();
+}
+
+inline void passSwiftClassToCxx(SwiftMod::ExposedToCxx value) {
+    value.setI(-11);
+    value.testMethod();
+}
+
+// FIXME: Add test for `moved` passThrough once 'move' is supported
+// for Swift class typesin C++.
+inline SwiftMod::ExposedToCxx passThroughSwiftClass(SwiftMod::ExposedToCxx value) {
+    auto copy = value;
+    value.setI(2);
+    return copy;
+}
+
+int puts(const char *);
+
+// FIXME: There's a bug where destructor isn't called if
+// it's not explicitly defined.
+class __attribute__((swift_attr("import_owned"))) InClass {
+    SwiftMod::ExposedToCxx value;
+public:
+    ~InClass() {
+        puts("destroy ~InClass()");
+    }
+    inline InClass(SwiftMod::ExposedToCxx value) : value(value) {}
+
+    inline SwiftMod::ExposedToCxx getValue() const {
+        return value;
+    }
+};
+
+#endif
+
+//--- module.modulemap
+module SwiftToCxxTest {
+    header "header.h"
+    requires cplusplus
+}
+
+//--- swiftMod.swift
+import SwiftToCxxTest
+
+public class ExposedToCxx {
+    public init() {
+        i = 0
+        print("ExposedToCxx.init")
+    }
+    deinit {
+        print("ExposedToCxx\(i).deinit")
+    }
+
+    public final func testMethod() {
+        print("ExposedToCxx\(i).testMethod")
+    }
+
+    public var i: Int
+}
+
+#if SECOND_PASS
+
+func testReceiveAndPassSwiftClass() {
+    let classInstance = createSwiftClassInCxx()
+    classInstance.testMethod()
+    classInstance.i = 12
+    classInstance.testMethod()
+    passSwiftClassToCxx(classInstance)
+    classInstance.testMethod()
+    passThroughSwiftClass(classInstance).testMethod()
+}
+
+testReceiveAndPassSwiftClass()
+
+func testReceiveAndPassSwiftClassInClass() {
+    let v = InClass(ExposedToCxx())
+    v.getValue().i = 75
+    v.getValue().testMethod()
+}
+
+testReceiveAndPassSwiftClassInClass()
+
+#endif
+
+// CHECK: ExposedToCxx.init
+// CHECK-NEXT: ExposedToCxx0.testMethod
+// CHECK-NEXT: ExposedToCxx12.testMethod
+// CHECK-NEXT: ExposedToCxx-11.testMethod
+// CHECK-NEXT: ExposedToCxx-11.testMethod
+// CHECK-NEXT: ExposedToCxx2.testMethod
+// CHECK-NEXT: ExposedToCxx2.deinit
+
+// CHECK: ExposedToCxx.init
+// CHECK-NEXT: ExposedToCxx75.testMethod
+// CHECK-NEXT: destroy ~InClass()
+// CHECK-NEXT: ExposedToCxx75.deinit