[cxx-interop] add SWIFT_NONCOPYABLE annotation

Author: hyp

lib/ClangImporter/ClangImporter.cpp

@@ -7076,6 +7076,14 @@ static bool hasIteratorAPIAttr(const clang::Decl *decl) {
          });
 }
 
+static bool hasNonCopyableAttr(const clang::RecordDecl *decl) {
+  return decl->hasAttrs() && llvm::any_of(decl->getAttrs(), [](auto *attr) {
+           if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr))
+             return swiftAttr->getAttribute() == "~Copyable";
+           return false;
+         });
+}
+
 /// Recursively checks that there are no pointers in any fields or base classes.
 /// Does not check C++ records with specific API annotations.
 static bool hasPointerInSubobjects(const clang::CXXRecordDecl *decl) {
@@ -7295,6 +7303,10 @@ CxxRecordSemantics::evaluate(Evaluator &evaluator,
     return CxxRecordSemanticsKind::MissingLifetimeOperation;
   }
 
+  if (hasNonCopyableAttr(cxxDecl) && hasMoveTypeOperations(cxxDecl)) {
+    return CxxRecordSemanticsKind::MoveOnly;
+  }
+
   if (hasOwnedValueAttr(cxxDecl)) {
     return CxxRecordSemanticsKind::Owned;
   }

lib/ClangImporter/bridging

@@ -153,6 +153,11 @@
 #define SWIFT_UNCHECKED_SENDABLE \
   __attribute__((swift_attr("@Sendable")))
 
+/// Specifies that a specific c++ type such class or struct should be imported
+/// as a non-copyable Swift value type.
+#define SWIFT_NONCOPYABLE \
+  __attribute__((swift_attr("~Copyable")))
+
 #else  // #if _CXX_INTEROP_HAS_ATTRIBUTE(swift_attr)
 
 // Empty defines for compilers that don't support `attribute(swift_attr)`.
@@ -166,6 +171,7 @@
 #define SWIFT_COMPUTED_PROPERTY
 #define SWIFT_MUTATING 
 #define SWIFT_UNCHECKED_SENDABLE
+#define SWIFT_NONCOPYABLE
 
 #endif // #if _CXX_INTEROP_HAS_ATTRIBUTE(swift_attr)
 

test/Interop/Cxx/class/Inputs/type-classification.h

@@ -251,4 +251,15 @@ struct HasMethodThatReturnsIteratorBox {
   IteratorBox getIteratorBox() const;
 };
 
+struct __attribute__((swift_attr("~Copyable"))) StructCopyableMovableAnnotatedNonCopyable {
+  inline StructCopyableMovableAnnotatedNonCopyable() {}
+  StructCopyableMovableAnnotatedNonCopyable(const StructCopyableMovableAnnotatedNonCopyable &) = default;
+  StructCopyableMovableAnnotatedNonCopyable(StructCopyableMovableAnnotatedNonCopyable &&) = default;
+  StructCopyableMovableAnnotatedNonCopyable &
+  operator=(const StructCopyableMovableAnnotatedNonCopyable &) = default;
+    StructCopyableMovableAnnotatedNonCopyable &
+  operator=(StructCopyableMovableAnnotatedNonCopyable &&) = default;
+  ~StructCopyableMovableAnnotatedNonCopyable() = default;
+};
+
 #endif // TEST_INTEROP_CXX_CLASS_INPUTS_TYPE_CLASSIFICATION_H

test/Interop/Cxx/class/type-classification-typechecker.swift

@@ -0,0 +1,13 @@
+// Test various aspects of the C++ `nodiscard` keyword.
+
+// RUN: %target-typecheck-verify-swift -I %S/Inputs -enable-experimental-cxx-interop
+
+import TypeClassification
+
+func test() {
+  let x = StructCopyableMovableAnnotatedNonCopyable()
+  let v = copy x // expected-error {{'copy' cannot be applied to noncopyable types}}
+  _ = v
+}
+
+test()

test/Interop/Cxx/ergonomics/swift-bridging-annotations.swift

@@ -84,6 +84,15 @@ class SWIFT_UNCHECKED_SENDABLE UnsafeSendable {
 public:
 };
 
+class SWIFT_NONCOPYABLE NonCopyableCopyable {
+public:
+    NonCopyableCopyable(const NonCopyableCopyable &other) = default;
+    NonCopyableCopyable(NonCopyableCopyable &&other);
+    ~NonCopyableCopyable();
+private:
+    int x;
+};
+
 
 // CHECK: struct SelfContained {
 
@@ -106,3 +115,5 @@ public:
 // CHECK: struct ConformsTo : Proto {
 
 // CHECK: struct UnsafeSendable : @unchecked Sendable {
+
+// CHECK: struct NonCopyableCopyable