[interop][SwiftToCxx] moving a Swift class in C++ performs a copy

C++ does not have a consuming move, so fallback to copy instead

Resolves #64702

(cherry picked from commit 16b1fe1)

Author: hyp

lib/PrintAsClang/_SwiftCxxInteroperability.h

@@ -159,18 +159,28 @@ class RefCountedClass {
       : _opaquePointer(other._opaquePointer) {
     swift_retain(_opaquePointer);
   }
+  SWIFT_INLINE_THUNK RefCountedClass(RefCountedClass &&other) noexcept
+      : _opaquePointer(other._opaquePointer) {
+    // Moving a Swift class reference is a copy
+    // in C++. This allows C++ to avoid liveness
+    // checks to see if the pointer is `null` or not,
+    // as C++'s move is not consuming, unlike Swift's.
+    swift_retain(_opaquePointer);
+  }
   SWIFT_INLINE_THUNK RefCountedClass &
   operator=(const RefCountedClass &other) noexcept {
     swift_retain(other._opaquePointer);
     swift_release(_opaquePointer);
     _opaquePointer = other._opaquePointer;
     return *this;
   }
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wmissing-noreturn"
-  // FIXME: implement 'move'?
-  SWIFT_INLINE_THUNK RefCountedClass(RefCountedClass &&) noexcept { abort(); }
-#pragma clang diagnostic pop
+  SWIFT_INLINE_THUNK RefCountedClass &
+  operator=(RefCountedClass &&other) noexcept {
+    swift_retain(other._opaquePointer);
+    swift_release(_opaquePointer);
+    _opaquePointer = other._opaquePointer;
+    return *this;
+  }
 
 protected:
   SWIFT_INLINE_THUNK RefCountedClass(void *_Nonnull ptr) noexcept

test/Interop/SwiftToCxx/class/swift-class-execution.cpp

@@ -102,6 +102,33 @@ int main() {
 // CHECK-NEXT: init ClassWithIntField
 // CHECK-NEXT: destroy ClassWithIntField
 // CHECK-NEXT: ClassWithIntField: 0;
+// CHECK-NEXT: destroy ClassWithIntField
+
+  {
+    auto x = returnClassWithIntField();
+    assert(getRetainCount(x) == 1);
+    ClassWithIntField x2(std::move(x));
+    // Moving a Swift class in C++ is not consuming.
+    assert(getRetainCount(x) == 2);
+  }
+// CHECK-NEXT: init ClassWithIntField
+// CHECK-NEXT: destroy ClassWithIntField
+
+  {
+      auto x = returnClassWithIntField();
+      auto x2 = returnClassWithIntField();
+      assert(getRetainCount(x) == 1);
+      assert(getRetainCount(x2) == 1);
+      x2 = std::move(x);
+      // Moving a Swift class in C++ is not consuming.
+      assert(getRetainCount(x) == 2);
+      assert(getRetainCount(x2) == 2);
+      takeClassWithIntField(x2);
+  }
+// CHECK-NEXT: init ClassWithIntField
+// CHECK-NEXT: init ClassWithIntField
+// CHECK-NEXT: destroy ClassWithIntField
+// CHECK-NEXT: ClassWithIntField: 0;
 // CHECK-NEXT: destroy ClassWithIntField
   return 0;
 }

test/Interop/SwiftToCxx/class/swift-class-inheritance-execution.cpp

@@ -95,6 +95,17 @@ int main() {
 // CHECK-NEXT: useDerivedClass, type=Class.DerivedDerivedClass
 // CHECK-NEXT: destroy DerivedDerivedClass
 // CHECK-NEXT: destroy DerivedClass
+// CHECK-NEXT: destroy BaseClass
+
+  {
+    BaseClass x = returnDerivedClass();
+    assert(getRetainCount(x) == 1);
+    useBaseClass(x);
+  }
+// CHECK-NEXT: init BaseClass
+// CHECK-NEXT: init DerivedClass
+// CHECK-NEXT: useBaseClass, type=Class.DerivedClass
+// CHECK-NEXT: destroy DerivedClass
 // CHECK-NEXT: destroy BaseClass
   return 0;
 }