[cxx-interop] fix support for value-only non-copyable type dereference

Author: hyp

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -1755,8 +1755,10 @@ SwiftDeclSynthesizer::makeDereferencedPointeeProperty(FuncDecl *getter,
                              ? rawElementTy->getAnyPointerElementType()
                              : rawElementTy;
   // Use 'address' or 'mutableAddress' accessors for non-copyable
-  // types.
-  bool useAddress = elementTy->isNoncopyable(dc);
+  // types that are returned indirectly.
+  bool isImplicit = !elementTy->isNoncopyable(dc);
+  bool useAddress =
+      rawElementTy->getAnyPointerElementType() && elementTy->isNoncopyable(dc);
 
   auto result = new (ctx)
       VarDecl(/*isStatic*/ false, VarDecl::Introducer::Var,
@@ -1773,7 +1775,7 @@ SwiftDeclSynthesizer::makeDereferencedPointeeProperty(FuncDecl *getter,
       ParameterList::createEmpty(ctx),
       useAddress ? elementTy->wrapInPointer(PTK_UnsafePointer) : elementTy, dc);
   getterDecl->setAccess(AccessLevel::Public);
-  if (!useAddress)
+  if (isImplicit)
     getterDecl->setImplicit();
   getterDecl->setIsDynamic(false);
   getterDecl->setIsTransparent(true);
@@ -1813,7 +1815,7 @@ SwiftDeclSynthesizer::makeDereferencedPointeeProperty(FuncDecl *getter,
                    : TupleType::getEmpty(ctx),
         dc);
     setterDecl->setAccess(AccessLevel::Public);
-    if (!useAddress)
+    if (isImplicit)
       setterDecl->setImplicit();
     setterDecl->setIsDynamic(false);
     setterDecl->setIsTransparent(true);

test/Interop/Cxx/operators/move-only/Inputs/move-only-cxx-value-operators.h

@@ -48,4 +48,16 @@ class NonCopyableHolderMutDeref {
     inline NonCopyable & operator *() { return x; }
 };
 
+class NonCopyableHolderValueConstDeref {
+    NONCOPYABLE_HOLDER_WRAPPER(NonCopyableHolderValueConstDeref)
+
+    inline NonCopyable operator *() const { return NonCopyable(x.x); }
+};
+
+class NonCopyableHolderValueMutDeref {
+    NONCOPYABLE_HOLDER_WRAPPER(NonCopyableHolderValueMutDeref)
+
+    inline NonCopyable operator *() { return NonCopyable(x.x); }
+};
+
 #endif // TEST_INTEROP_CXX_OPERATORS_MOVE_ONLY_OPS_H

test/Interop/Cxx/operators/move-only/move-only-synthesized-properties.swift

@@ -67,5 +67,18 @@ MoveOnlyCxxOperators.test("testNonCopyableHolderMutDeref pointee borrow") {
   expectEqual(holder.pointee.x, 0)
 }
 
+MoveOnlyCxxOperators.test("testNonCopyableHolderValueConstDeref pointee value") {
+  let holder = NonCopyableHolderValueConstDeref(11)
+  var k = holder.pointee
+  var k2 = holder.pointee
+  expectEqual(k.x, k2.x)
+}
+
+MoveOnlyCxxOperators.test("testNonCopyableHolderValueMutDeref pointee value") {
+  var holder = NonCopyableHolderValueMutDeref(11)
+  var k = holder.pointee
+  var k2 = holder.pointee
+  expectEqual(k.x, k2.x)
+}
 
 runAllTests()

test/Interop/Cxx/operators/move-only/move-only-synthesized-property-typecheck.swift

@@ -66,7 +66,27 @@ func testNonCopyableHolderMutDerefPointeeLet() {
 #endif
 }
 
+func testNonCopyableHolderValueConstDerefPointeeLet() {
+    let holder = NonCopyableHolderValueConstDeref(11)
+    let val = holder.pointee // expected-note {{}}
+    _ = borrowNC(val) // ok
+#if NO_CONSUME
+    val.mutMethod(3) // expected-error {{cannot use mutating member on immutable value: 'val' is a 'let' constant}}
+#endif
+}
+
+func testNonCopyableHolderValueMutDerefPointeeLet() {
+    var holder = NonCopyableHolderValueMutDeref(11)
+    let val = holder.pointee // expected-note {{}}
+    _ = borrowNC(val) // ok
+#if NO_CONSUME
+    val.mutMethod(3) // expected-error {{cannot use mutating member on immutable value: 'val' is a 'let' constant}}
+#endif
+}
+
 testNonCopyableHolderConstDerefPointee()
 testNonCopyableHolderPairedDerefPointee()
 testNonCopyableHolderMutDerefPointee()
 testNonCopyableHolderMutDerefPointeeLet()
+testNonCopyableHolderValueConstDerefPointeeLet()
+testNonCopyableHolderValueMutDerefPointeeLet()