Merge pull request swiftlang#78084 from swiftlang/egorzhdan/6.1-relax-cxx-resilience

🍒[cxx-interop] Allow more C++ decls in public Swift interfaces

Author: egorzhdan

lib/Sema/TypeCheckAccess.cpp

@@ -1828,6 +1828,8 @@ class UsableFromInlineChecker : public AccessControlCheckerBase,
   }
 };
 
+bool isFragileClangDecl(const clang::Decl *decl);
+
 bool isFragileClangType(clang::QualType type) {
   if (type.isNull())
     return true;
@@ -1842,20 +1844,21 @@ bool isFragileClangType(clang::QualType type) {
   // Pointers to non-fragile types are non-fragile.
   if (underlyingTypePtr->isPointerType())
     return isFragileClangType(underlyingTypePtr->getPointeeType());
+  if (auto tagDecl = underlyingTypePtr->getAsTagDecl())
+    return isFragileClangDecl(tagDecl);
   return true;
 }
 
-bool isFragileClangNode(const ClangNode &node) {
-  auto *decl = node.getAsDecl();
-  if (!decl)
-    return false;
+bool isFragileClangDecl(const clang::Decl *decl) {
   // Namespaces by themselves don't impact ABI.
   if (isa<clang::NamespaceDecl>(decl))
     return false;
   // Objective-C type declarations are compatible with library evolution.
   if (isa<clang::ObjCContainerDecl>(decl))
     return false;
   if (auto *fd = dyn_cast<clang::FunctionDecl>(decl)) {
+    if (auto *ctorDecl = dyn_cast<clang::CXXConstructorDecl>(fd))
+      return isFragileClangDecl(ctorDecl->getParent());
     if (!isa<clang::CXXMethodDecl>(decl) &&
         !isFragileClangType(fd->getDeclaredReturnType())) {
       for (const auto *param : fd->parameters()) {
@@ -1885,13 +1888,27 @@ bool isFragileClangNode(const ClangNode &node) {
   if (auto *typedefDecl = dyn_cast<clang::TypedefNameDecl>(decl))
     return isFragileClangType(typedefDecl->getUnderlyingType());
   if (auto *rd = dyn_cast<clang::RecordDecl>(decl)) {
-    if (!isa<clang::CXXRecordDecl>(rd))
+    auto cxxRecordDecl = dyn_cast<clang::CXXRecordDecl>(rd);
+    if (!cxxRecordDecl)
       return false;
-    return !rd->getDeclContext()->isExternCContext();
-  }
+    return !cxxRecordDecl->isCLike() &&
+           !cxxRecordDecl->getDeclContext()->isExternCContext();
+  }
+  if (auto *varDecl = dyn_cast<clang::VarDecl>(decl))
+    return isFragileClangType(varDecl->getType());
+  if (auto *fieldDecl = dyn_cast<clang::FieldDecl>(decl))
+    return isFragileClangType(fieldDecl->getType()) ||
+           isFragileClangDecl(fieldDecl->getParent());
   return true;
 }
 
+bool isFragileClangNode(const ClangNode &node) {
+  auto *decl = node.getAsDecl();
+  if (!decl)
+    return false;
+  return isFragileClangDecl(decl);
+}
+
 } // end anonymous namespace
 
 /// Returns the kind of origin, implementation-only import or SPI declaration,

test/Interop/Cxx/library-evolution/Inputs/module.modulemap

@@ -0,0 +1,4 @@
+module MyCLibrary {
+  header "my_c_header.h"
+  export *
+}

test/Interop/Cxx/library-evolution/Inputs/my_c_header.h

@@ -0,0 +1,3 @@
+struct MyCStruct {
+  int x;
+};

test/Interop/Cxx/library-evolution/allow-c-in-cxx-mode-in-interfaces.swift

@@ -0,0 +1,41 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// Build a Swift library that uses symbols from a C library without enabling C++ interop.
+// RUN: %target-build-swift %t/uses-c-library.swift -emit-module -emit-library -enable-library-evolution -module-name UsesCLibrary -emit-module-path %t/artifacts/UsesCLibrary.swiftmodule -emit-module-interface-path %t/artifacts/UsesCLibrary.swiftinterface -I %S/Inputs
+
+// Make sure the module interface can be type-checked with C++ interop enabled.
+// RUN: %target-swift-frontend -typecheck-module-from-interface -cxx-interoperability-mode=default %t/artifacts/UsesCLibrary.swiftinterface -I %S/Inputs
+
+// Make sure we can build a Swift executable that uses the library and enables C++ interop.
+// RUN: %target-swift-frontend -typecheck -cxx-interoperability-mode=default -module-name Main %t/main.swift -I %t/artifacts -I %S/Inputs
+
+//--- uses-c-library.swift
+
+import MyCLibrary
+
+public func getMyCStruct() -> MyCStruct {
+  return MyCStruct()
+}
+
+extension MyCStruct {
+  @inlinable public var y: CInt {
+    get {
+      return self.x
+    }
+  }
+
+  @inlinable public var anotherInstanceOfSelf: MyCStruct {
+    get {
+      return MyCStruct(x: self.x + 1)
+    }
+  }
+}
+
+//--- main.swift
+
+import UsesCLibrary
+
+let _ = getMyCStruct()
+let _ = getMyCStruct().y
+let _ = getMyCStruct().anotherInstanceOfSelf