[cxx-interop] Fix calling convention for rvalue reference params

In C++, we always expected to invoke the dtor for moved-from objects.
This is not the case for swift. Fortunately, @incxx calling convention
is already expressing that the caller supposed to destroy the object.
This fixes the missing dtor calls when calling C++ functions taking
rvalue references. Fixes #77894.

rdar://140786022

Author: Gabor Horvath

lib/SIL/IR/SILFunctionType.cpp

@@ -1256,6 +1256,9 @@ class Conventions {
     case ValueOwnership::Shared:
       return ParameterConvention::Indirect_In_Guaranteed;
     case ValueOwnership::Owned:
+      if (kind == ConventionsKind::CFunction ||
+          kind == ConventionsKind::CFunctionType)
+        return getIndirectParameter(index, type, substTL);
       return ParameterConvention::Indirect_In;
     }
     llvm_unreachable("unhandled ownership");
@@ -3392,6 +3395,8 @@ static ParameterConvention getIndirectCParameterConvention(clang::QualType type)
   // A trivial const * parameter in C should be considered @in.
   if (importer::isCxxConstReferenceType(type.getTypePtr()))
     return ParameterConvention::Indirect_In_Guaranteed;
+  if (type->isRValueReferenceType())
+    return ParameterConvention::Indirect_In_CXX;
   if (auto *decl = type->getAsRecordDecl()) {
     if (!decl->isParamDestroyedInCallee())
       return ParameterConvention::Indirect_In_CXX;

lib/SILGen/SILGenApply.cpp

@@ -4655,7 +4655,8 @@ static void emitConsumedLValueRecursive(SILGenFunction &SGF, SILLocation loc,
 
   // Load if necessary.
   if (value.getType().isAddress()) {
-    if (!param.isIndirectIn() || !SGF.silConv.useLoweredAddresses()) {
+    if ((!param.isIndirectIn() && !param.isIndirectInCXX()) ||
+        !SGF.silConv.useLoweredAddresses()) {
       value = SGF.B.createFormalAccessLoadTake(loc, value);
 
       // If our value is a moveonlywrapped type, unwrap it using owned so that

test/Interop/Cxx/reference/Inputs/module.modulemap

@@ -3,6 +3,11 @@ module Reference {
   requires cplusplus
 }
 
+module SpecialMembers {
+  header "print-special-members.h"
+  requires cplusplus
+}
+
 module Closures {
   header "closures.h"
   requires cplusplus

test/Interop/Cxx/reference/Inputs/print-special-members.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <iostream>
+
+struct MoveOnly {
+    int id;
+    MoveOnly() : id(0) { std::cout << "MoveOnly " << id << " created\n"; }
+    MoveOnly(const MoveOnly&) = delete;
+    MoveOnly(MoveOnly&& other) : id(other.id + 1) { std::cout << "MoveOnly " << id << " move-created\n"; }
+    ~MoveOnly() { std::cout << "MoveOnly " << id << " destroyed\n"; }
+};
+
+struct Copyable {
+    int id;
+    Copyable() : id(0) { std::cout << "Copyable " << id << " created\n"; }
+    Copyable(const Copyable& other) : id(other.id + 1) { std::cout << "Copyable " << id << " copy-created\n"; }
+    Copyable(Copyable&& other) : id(other.id + 1) { std::cout << "Copyable " << id << " move-created\n"; }
+    ~Copyable() { std::cout << "Copyable " << id << " destroyed\n"; }
+};
+
+inline void byRValueRef(MoveOnly&& x) {}
+inline void byRValueRef(Copyable&& x) {}

test/Interop/Cxx/reference/rvalue-reference.swift

@@ -0,0 +1,41 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs/ -Xfrontend -enable-experimental-cxx-interop) | %FileCheck %s
+//
+// REQUIRES: executable_test
+
+import SpecialMembers
+
+func consume(_ x: consuming MoveOnly) {}
+func consume(_ x: consuming Copyable) {}
+
+func main() {
+    let x = MoveOnly()
+// CHECK: MoveOnly 0 created
+    byRValueRef(consuming: x)
+// CHECK-NEXT: MoveOnly 1 move-created
+// CHECK-NEXT: MoveOnly 0 destroyed
+// CHECK-NEXT: MoveOnly 1 destroyed
+    let x2 = MoveOnly()
+// CHECK-NEXT: MoveOnly 0 created
+    consume(x2)
+// CHECK-NEXT: MoveOnly 1 move-created
+// CHECK-NEXT: MoveOnly 0 destroyed
+// CHECK-NEXT: MoveOnly 2 move-created
+// CHECK-NEXT: MoveOnly 1 destroyed
+// CHECK-NEXT: MoveOnly 2 destroyed
+    let x3 = Copyable()
+// CHECK-NEXT: Copyable 0 created
+    byRValueRef(consuming: x3)
+// CHECK-NEXT: Copyable 1 copy-created
+// CHECK-NEXT: Copyable 1 destroyed
+    let x4 = Copyable()
+// CHECK-NEXT: Copyable 0 created
+    consume(x4)
+// CHECK-NEXT: Copyable 1 copy-created
+// CHECK-NEXT: Copyable 2 move-created
+// CHECK-NEXT: Copyable 1 destroyed
+// CHECK-NEXT: Copyable 2 destroyed
+// CHECK-NEXT: Copyable 0 destroyed
+// CHECK-NEXT: Copyable 0 destroyed
+}
+
+main()