[cxx-interop] add support for 'mutableAddress' pointee for non-copyable C++ types

Author: hyp

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -1542,6 +1542,29 @@ synthesizeUnwrappingGetterOrAddressGetterBody(AbstractFunctionDecl *afd,
     pointeePropertyRefExpr->setType(elementTy);
     propertyExpr = pointeePropertyRefExpr;
   }
+  // Cast an 'address' result from a mutable pointer if needed.
+  if (isAddress &&
+      getterImpl->getResultInterfaceType()->isUnsafeMutablePointer()) {
+    auto reinterpretCast = cast<FuncDecl>(
+        getBuiltinValueDecl(ctx, ctx.getIdentifier("reinterpretCast")));
+    auto rawTy = getterImpl->getResultInterfaceType();
+    auto enumTy = elementTy;
+    SubstitutionMap subMap = SubstitutionMap::get(
+        reinterpretCast->getGenericSignature(), {rawTy, enumTy}, {});
+    ConcreteDeclRef concreteDeclRef(reinterpretCast, subMap);
+    auto reinterpretCastRef = new (ctx)
+        DeclRefExpr(concreteDeclRef, DeclNameLoc(), /*implicit*/ true);
+    FunctionType::ExtInfo info;
+    reinterpretCastRef->setType(
+        FunctionType::get({FunctionType::Param(rawTy)}, enumTy, info));
+
+    auto *argList = ArgumentList::forImplicitUnlabeled(ctx, {propertyExpr});
+    auto reinterpreted =
+        CallExpr::createImplicit(ctx, reinterpretCastRef, argList);
+    reinterpreted->setType(enumTy);
+    reinterpreted->setThrows(nullptr);
+    propertyExpr = reinterpreted;
+  }
 
   auto returnStmt = new (ctx) ReturnStmt(SourceLoc(), propertyExpr,
                                          /*implicit*/ true);
@@ -1611,6 +1634,26 @@ synthesizeUnwrappingSetterBody(AbstractFunctionDecl *afd, void *context) {
   return {body, /*isTypeChecked*/ true};
 }
 
+static std::pair<BraceStmt *, bool>
+synthesizeUnwrappingAddressSetterBody(AbstractFunctionDecl *afd,
+                                      void *context) {
+  auto setterDecl = cast<AccessorDecl>(afd);
+  auto setterImpl = static_cast<FuncDecl *>(context);
+
+  ASTContext &ctx = setterDecl->getASTContext();
+
+  auto selfArg = createSelfArg(setterDecl);
+  auto *setterImplCallExpr =
+      createAccessorImplCallExpr(setterImpl, selfArg, nullptr);
+
+  auto returnStmt = new (ctx) ReturnStmt(SourceLoc(), setterImplCallExpr,
+                                         /*implicit*/ true);
+
+  auto body = BraceStmt::create(ctx, SourceLoc(), {returnStmt}, SourceLoc(),
+                                /*implicit*/ true);
+  return {body, /*isTypeChecked*/ true};
+}
+
 SubscriptDecl *SwiftDeclSynthesizer::makeSubscript(FuncDecl *getter,
                                                    FuncDecl *setter) {
   assert((getter || setter) &&
@@ -1755,8 +1798,9 @@ SwiftDeclSynthesizer::makeDereferencedPointeeProperty(FuncDecl *getter,
     paramVarDecl->setSpecifier(ParamSpecifier::Default);
     paramVarDecl->setInterfaceType(elementTy);
 
-    auto setterParamList =
-        ParameterList::create(ctx, {paramVarDecl});
+    auto setterParamList = useAddress
+                               ? ParameterList::create(ctx, {})
+                               : ParameterList::create(ctx, {paramVarDecl});
 
     setterDecl = AccessorDecl::create(
         ctx, setterImpl->getLoc(), setterImpl->getLoc(),
@@ -1773,7 +1817,10 @@ SwiftDeclSynthesizer::makeDereferencedPointeeProperty(FuncDecl *getter,
       setterDecl->setImplicit();
     setterDecl->setIsDynamic(false);
     setterDecl->setIsTransparent(true);
-    setterDecl->setBodySynthesizer(synthesizeUnwrappingSetterBody, setterImpl);
+    setterDecl->setBodySynthesizer(useAddress
+                                       ? synthesizeUnwrappingAddressSetterBody
+                                       : synthesizeUnwrappingSetterBody,
+                                   setterImpl);
 
     if (setterImpl->isMutating()) {
       setterDecl->setSelfAccessKind(SelfAccessKind::Mutating);

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

@@ -35,4 +35,17 @@ class NonCopyableHolderConstDeref {
     inline const NonCopyable & operator *() const { return x; }
 };
 
+class NonCopyableHolderPairedDeref {
+    NONCOPYABLE_HOLDER_WRAPPER(NonCopyableHolderPairedDeref)
+
+    inline const NonCopyable & operator *() const { return x; }
+    inline NonCopyable & operator *() { return x; }
+};
+
+class NonCopyableHolderMutDeref {
+    NONCOPYABLE_HOLDER_WRAPPER(NonCopyableHolderMutDeref)
+
+    inline NonCopyable & operator *() { return x; }
+};
+
 #endif // TEST_INTEROP_CXX_OPERATORS_MOVE_ONLY_OPS_H

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

@@ -29,4 +29,43 @@ MoveOnlyCxxOperators.test("NonCopyableHolderConstDeref pointee borrow") {
   expectEqual(k, 11)
 }
 
+MoveOnlyCxxOperators.test("testNonCopyableHolderPairedDeref pointee borrow") {
+  var holder = NonCopyableHolderPairedDeref(11)
+  var k = borrowNC(holder.pointee)
+  expectEqual(k, 33)
+  k = holder.pointee.method(2)
+  expectEqual(k, 22)
+  k = holder.pointee.x
+  expectEqual(k, 11)
+  k = inoutNC(&holder.pointee, -1)
+  expectEqual(k, -1)
+  expectEqual(holder.pointee.x, -1)
+  holder.pointee.mutMethod(3)
+  expectEqual(holder.pointee.x, 3)
+  holder.pointee.x = 34
+  expectEqual(holder.pointee.x, 34)
+  consumingNC(holder.pointee)
+  expectEqual(holder.pointee.x, 0)
+}
+
+MoveOnlyCxxOperators.test("testNonCopyableHolderMutDeref pointee borrow") {
+  var holder = NonCopyableHolderMutDeref(11)
+  var k = borrowNC(holder.pointee)
+  expectEqual(k, 33)
+  k = holder.pointee.method(2)
+  expectEqual(k, 22)
+  k = holder.pointee.x
+  expectEqual(k, 11)
+  k = inoutNC(&holder.pointee, -1)
+  expectEqual(k, -1)
+  expectEqual(holder.pointee.x, -1)
+  holder.pointee.mutMethod(3)
+  expectEqual(holder.pointee.x, 3)
+  holder.pointee.x = 34
+  expectEqual(holder.pointee.x, 34)
+  consumingNC(holder.pointee)
+  expectEqual(holder.pointee.x, 0)
+}
+
+
 runAllTests()

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

@@ -33,4 +33,40 @@ func testNonCopyableHolderConstDerefPointee() {
 #endif
 }
 
+func testNonCopyableHolderPairedDerefPointee() {
+    var holder = NonCopyableHolderPairedDeref(11)
+    _ = borrowNC(holder.pointee) // ok
+    _ = holder.pointee.method(2)
+    _ = holder.pointee.x
+    _ = inoutNC(&holder.pointee)
+    _ = holder.pointee.mutMethod(1)
+    holder.pointee.x = 2
+    consumingNC(holder.pointee)
+    let consumeVal = holder.pointee
+    _ = borrowNC(consumeVal)
+}
+
+func testNonCopyableHolderMutDerefPointee() {
+    var holder = NonCopyableHolderMutDeref(11)
+    _ = borrowNC(holder.pointee) // ok
+    _ = holder.pointee.method(2)
+    _ = holder.pointee.x
+    _ = inoutNC(&holder.pointee)
+    _ = holder.pointee.mutMethod(1)
+    holder.pointee.x = 2
+    consumingNC(holder.pointee)
+    let consumeVal = holder.pointee
+    _ = borrowNC(consumeVal)
+}
+
+func testNonCopyableHolderMutDerefPointeeLet() {
+#if NO_CONSUME
+    let holder = NonCopyableHolderMutDeref(11) // expected-note {{}}
+    _ = borrowNC(holder.pointee) // expected-error {{cannot use mutating getter on immutable value: 'holder' is a 'let' constant}}
+#endif
+}
+
 testNonCopyableHolderConstDerefPointee()
+testNonCopyableHolderPairedDerefPointee()
+testNonCopyableHolderMutDerefPointee()
+testNonCopyableHolderMutDerefPointeeLet()