[interop][SwiftToCxx] pass C++ value types into Swift correctly

Author: hyp

lib/PrintAsClang/PrintClangFunction.cpp

@@ -310,7 +310,12 @@ class CFunctionSignatureTypePrinter
       ClangTypeHandler handler(decl->getClangDecl());
       if (!handler.isRepresentable())
         return ClangRepresentation::unsupported;
+      if (typeUseKind == FunctionSignatureTypeUse::ParamType &&
+          !isInOutParam)
+        os << "const ";
       handler.printTypeName(os);
+      if (typeUseKind == FunctionSignatureTypeUse::ParamType)
+        os << '&';
       return ClangRepresentation::representable;
     }
 
@@ -859,11 +864,22 @@ void DeclAndTypeClangFunctionPrinter::printCxxToCFunctionParameterUse(
         if (!directTypeEncoding.empty())
           os << cxx_synthesis::getCxxImplNamespaceName()
              << "::swift_interop_passDirect_" << directTypeEncoding << '(';
-        ClangValueTypePrinter(os, cPrologueOS, interopContext)
-            .printParameterCxxToCUseScaffold(
-                moduleContext,
-                [&]() { printTypeImplTypeSpecifier(type, moduleContext); },
-                namePrinter, isSelf);
+        if (decl->hasClangNode()) {
+            if (!directTypeEncoding.empty())
+                os << "reinterpret_cast<const char *>(";
+            os << "swift::" << cxx_synthesis::getCxxImplNamespaceName()
+               << "::getOpaquePointer(";
+            namePrinter();
+            os << ')';
+            if (!directTypeEncoding.empty())
+                os << ')';
+        } else {
+            ClangValueTypePrinter(os, cPrologueOS, interopContext)
+                .printParameterCxxToCUseScaffold(
+                                                 moduleContext,
+                                                 [&]() { printTypeImplTypeSpecifier(type, moduleContext); },
+                                                 namePrinter, isSelf);
+        }
         if (!directTypeEncoding.empty())
           os << ')';
         return;

test/Interop/CxxToSwiftToCxx/bridge-cxx-struct-back-to-cxx-execution.cpp

@@ -28,7 +28,9 @@ struct NonTrivialTemplate {
     inline NonTrivialTemplate(T x) : x(x) {
         puts("create NonTrivialTemplate");
     }
-    inline NonTrivialTemplate(const NonTrivialTemplate<T> &) = default;
+    inline NonTrivialTemplate(const NonTrivialTemplate<T> &other) : x(other.x) {
+        puts("copy NonTrivialTemplate");
+    }
     inline NonTrivialTemplate(NonTrivialTemplate<T> &&other) : x(static_cast<T &&>(other.x)) {
         puts("move NonTrivialTemplate");
     }
@@ -50,10 +52,34 @@ public func retNonTrivial(y: CInt) -> NonTrivialTemplate<Trivial> {
     return NonTrivialTemplate<Trivial>(Trivial(42, y))
 }
 
+public func takeNonTrivial(_ x: NonTrivialTemplate<Trivial>) {
+    print(x)
+}
+
+public func passThroughNonTrivial(_ x: NonTrivialTemplate<Trivial>) -> NonTrivialTemplate<Trivial>{
+    return x
+}
+
+public func inoutNonTrivial(_ x: inout NonTrivialTemplate<Trivial>) {
+    x.x.y *= 2
+}
+
 public func retTrivial(_ x: CInt) -> Trivial {
     return Trivial(x, -x)
 }
 
+public func takeTrivial(_ x: Trivial) {
+    print(x)
+}
+
+public func passThroughTrivial(_ x: Trivial) -> Trivial {
+    return x
+}
+
+public func inoutTrivial(_ x: inout Trivial) {
+    x.x = x.y + x.x - 11
+}
+
 //--- use-swift-cxx-types.cpp
 
 #include "header.h"
@@ -65,15 +91,37 @@ int main() {
     auto x = UseCxx::retTrivial(423421);
     assert(x.x == 423421);
     assert(x.y == -423421);
+    UseCxx::takeTrivial(UseCxx::passThroughTrivial(x));
+    assert(x.x == 423421);
+    assert(x.y == -423421);
+    UseCxx::inoutTrivial(x);
+    assert(x.x == -11);
+    assert(x.y == -423421);
+    UseCxx::takeTrivial(x);
   }
+// CHECK: Trivial(x: 423421, y: -423421)
+// CHECK-NEXT: Trivial(x: -11, y: -423421)
   {
     auto x = UseCxx::retNonTrivial(-942);
     assert(x.x.y == -942);
     assert(x.x.x == 42);
+    UseCxx::takeNonTrivial(UseCxx::passThroughNonTrivial(x));
+    puts("done non trivial");
+    UseCxx::inoutNonTrivial(x);
+    assert(x.x.y == -1884);
+    assert(x.x.x == 42);
   }
-// CHECK: create NonTrivialTemplate
+// CHECK-NEXT: create NonTrivialTemplate
+// CHECK-NEXT: move NonTrivialTemplate
+// CHECK-NEXT: ~NonTrivialTemplate
+// CHECK-NEXT: copy NonTrivialTemplate
 // CHECK-NEXT: move NonTrivialTemplate
 // CHECK-NEXT: ~NonTrivialTemplate
+// CHECK-NEXT: copy NonTrivialTemplate
+// CHECK-NEXT: __CxxTemplateInst18NonTrivialTemplateI7TrivialE(x: __C.Trivial(x: 42, y: -942))
+// CHECK-NEXT: ~NonTrivialTemplate
+// CHECK-NEXT: ~NonTrivialTemplate
+// CHECK-NEXT: done non trivial
 // CHECK-NEXT: ~NonTrivialTemplate
   return 0;
 }

test/Interop/CxxToSwiftToCxx/bridge-cxx-struct-back-to-cxx.swift

@@ -71,6 +71,15 @@ public func retTrivial() -> Trivial {
     return Trivial()
 }
 
+public func takeNonTrivial2(_ x: ns.NonTrivialTemplate<ns.TrivialinNS>) {
+}
+
+public func takeTrivial(_ x: Trivial) {
+}
+
+public func takeTrivialInout(_ x: inout Trivial) {
+}
+
 // CHECK: #if __has_feature(objc_modules)
 // CHECK: #if __has_feature(objc_modules)
 // CHECK-NEXT: #if __has_warning("-Watimport-in-framework-header")
@@ -120,3 +129,14 @@ public func retTrivial() -> Trivial {
 // CHECK-NEXT: return *storageObjectPtr;
 // CHECK-NEXT: }
 
+// CHECK: inline void takeNonTrivial2(const ns::NonTrivialTemplate<ns::TrivialinNS>& x) noexcept {
+// CHECK-NEXT:   return _impl::$s8UseCxxTy15takeNonTrivial2yySo2nsO02__b18TemplateInstN2ns18e7TrivialH20INS_11TrivialinNSEEEVF(swift::_impl::getOpaquePointer(x));
+// CHECK-NEXT: }
+
+// CHECK: inline void takeTrivial(const Trivial& x) noexcept {
+// CHECK-NEXT:   return _impl::$s8UseCxxTy11takeTrivialyySo0E0VF(_impl::swift_interop_passDirect_UseCxxTy_uint32_t_0_4(reinterpret_cast<const char *>(swift::_impl::getOpaquePointer(x))));
+// CHECK-NEXT: }
+
+// CHECK: inline void takeTrivialInout(Trivial& x) noexcept {
+// CHECK-NEXT:   return _impl::$s8UseCxxTy16takeTrivialInoutyySo0E0VzF(swift::_impl::getOpaquePointer(x));
+// CHECK-NEXT: }