Merge pull request #64473 from hyp/eng/swift-class-to-cxx-to-swift-infinity

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

Author: swift-ci

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

@@ -1106,6 +1106,9 @@ namespace {
         auto parentNS = cast<clang::NamespaceDecl>(decl->getParent());
         auto parent =
             Impl.importDecl(parentNS, getVersion(), /*UseCanonicalDecl*/ false);
+        // The parent namespace might not be imported if it's `swift_private`.
+        if (!parent)
+            return nullptr;
         dc = cast<EnumDecl>(parent);
       }
 
@@ -2621,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/PrintAsClang/PrintClangValueType.cpp

@@ -544,7 +544,7 @@ void ClangValueTypePrinter::printTypePrecedingGenericTraits(
   ClangSyntaxPrinter printer(os);
   // FIXME: avoid popping out of the module's namespace here.
   os << "} // end namespace \n\n";
-  os << "namespace swift {\n";
+  os << "namespace swift SWIFT_PRIVATE_ATTR {\n";
 
   os << "#pragma clang diagnostic push\n";
   os << "#pragma clang diagnostic ignored \"-Wc++17-extensions\"\n";
@@ -570,7 +570,7 @@ void ClangValueTypePrinter::printTypeGenericTraits(
   ClangSyntaxPrinter printer(os);
   // FIXME: avoid popping out of the module's namespace here.
   os << "} // end namespace \n\n";
-  os << "namespace swift {\n";
+  os << "namespace swift SWIFT_PRIVATE_ATTR {\n";
 
   if (typeDecl->hasClangNode()) {
     /// Print a reference to the type metadata fucntion for a C++ type.

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/CxxToSwiftToCxx/bridge-cxx-struct-back-to-cxx.swift

@@ -166,7 +166,7 @@ public func takeTrivialInout(_ x: inout Trivial) {
 
 // CHECK: } // end namespace
 // CHECK-EMPTY:
-// CHECK-NEXT: namespace swift {
+// CHECK-NEXT: namespace swift SWIFT_PRIVATE_ATTR {
 // CHECK-NEXT: namespace _impl {
 // CHECK-EMPTY:
 // CHECK-NEXT: // Type metadata accessor for NonTrivialTemplateInt
@@ -205,7 +205,7 @@ public func takeTrivialInout(_ x: inout Trivial) {
 // CHECK-EMPTY:
 // CHECK-NEXT: } // end namespace
 // CHECK-EMPTY:
-// CHECK-NEXT: namespace swift {
+// CHECK-NEXT: namespace swift SWIFT_PRIVATE_ATTR {
 // CHECK-NEXT: namespace _impl {
 // CHECK-EMPTY:
 // CHECK-NEXT: // Type metadata accessor for NonTrivialTemplateTrivial

test/Interop/SwiftToCxx/class/swift-class-in-cxx.swift

@@ -34,7 +34,7 @@ public final class ClassWithIntField {
 // CHECK-NEXT: } // end namespace
 
 // CHECK: namespace
-// CHECK-SAME: swift {
+// CHECK-SAME: swift SWIFT_PRIVATE_ATTR {
 // CHECK-NEXT: #pragma clang diagnostic push
 // CHECK-NEXT: #pragma clang diagnostic ignored "-Wc++17-extensions"
 // CHECK-NEXT: template<>
@@ -84,7 +84,7 @@ public final class ClassWithIntField {
 // CHECK-EMPTY:
 // CHECK-NEXT: } // end namespace
 // CHECK-EMPTY:
-// CHECK-NEXT: namespace swift {
+// CHECK-NEXT: namespace swift SWIFT_PRIVATE_ATTR {
 // CHECK-NEXT: #pragma clang diagnostic push
 // CHECK-NEXT: #pragma clang diagnostic ignored "-Wc++17-extensions"
 // CHECK-NEXT: template<>

test/Interop/SwiftToCxx/generics/generic-struct-in-cxx.swift

@@ -261,7 +261,7 @@ public func inoutConcretePair(_ x: UInt16, _ y: inout GenericPair<UInt16, UInt16
 // CHECK-NEXT:   return result;
 // CHECK-NEXT: }
 
-// CHECK: namespace swift {
+// CHECK: namespace swift SWIFT_PRIVATE_ATTR {
 // CHECK-NEXT: #pragma clang diagnostic push
 // CHECK-NEXT: #pragma clang diagnostic ignored "-Wc++17-extensions"
 // CHECK-NEXT: template<class T_0_0, class T_0_1>