Merge pull request #72511 from gottesmm/pr-53cba94c2ed0b09cc127d2cd80c2758b0f473aea

[transferring] Implement swift_attr support for transferring results and parameters.

Author: gottesmm

lib/ClangImporter/ClangImporter.cpp

@@ -610,7 +610,7 @@ void importer::getNormalInvocationArguments(
     // '@_nonSendable' on Clang declarations is fully supported, including the
     // 'attribute push' pragma.
     if (clangSupportsPragmaAttributeWithSwiftAttr())
-      invocationArgStrs.push_back( "-D__SWIFT_ATTR_SUPPORTS_SENDABLE_DECLS=1");
+      invocationArgStrs.push_back("-D__SWIFT_ATTR_SUPPORTS_SENDABLE_DECLS=1");
 
     // Get the version of this compiler and pass it to C/Objective-C
     // declarations.
@@ -661,6 +661,11 @@ void importer::getNormalInvocationArguments(
     }
   }
 
+  // If we support TransferringArgsAndResults, set the -D flag to signal that it
+  // is supported.
+  if (LangOpts.hasFeature(Feature::TransferringArgsAndResults))
+    invocationArgStrs.push_back("-D__SWIFT_ATTR_SUPPORTS_TRANSFERRING=1");
+
   if (searchPathOpts.getSDKPath().empty()) {
     invocationArgStrs.push_back("-Xclang");
     invocationArgStrs.push_back("-nostdsysteminc");

lib/ClangImporter/ImportDecl.cpp

@@ -8063,6 +8063,18 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
         nominal->registerProtocolConformance(conformance, /*synthesized=*/true);
       }
 
+      if (swiftAttr->getAttribute() == "transferring") {
+        // Swallow this if the feature is not enabled.
+        if (!SwiftContext.LangOpts.hasFeature(
+                Feature::TransferringArgsAndResults))
+          continue;
+        auto *funcDecl = dyn_cast<FuncDecl>(MappedDecl);
+        if (!funcDecl)
+          continue;
+        funcDecl->setTransferringResult();
+        continue;
+      }
+
       // Dig out a buffer with the attribute text.
       unsigned bufferID = getClangSwiftAttrSourceBuffer(
           swiftAttr->getAttribute());

lib/ClangImporter/ImportType.cpp

@@ -2577,6 +2577,18 @@ static ParamDecl *getParameterInfo(ClangImporter::Implementation *impl,
       param, AccessLevel::Private, SourceLoc(), SourceLoc(), name,
       impl->importSourceLoc(param->getLocation()), bodyName,
       impl->ImportedHeaderUnit);
+
+  // If TransferringArgsAndResults are enabled and we have a transferring
+  // argument, set that the param was transferring.
+  if (paramInfo->getASTContext().LangOpts.hasFeature(
+          Feature::TransferringArgsAndResults)) {
+    if (auto *attr = param->getAttr<clang::SwiftAttrAttr>()) {
+      if (attr->getAttribute() == "transferring") {
+        paramInfo->setTransferring();
+      }
+    }
+  }
+
   // Foreign references are already references so they don't need to be passed
   // as inout.
   paramInfo->setSpecifier(isInOut && !swiftParamTy->isForeignReferenceType()

test/ClangImporter/Inputs/transferring.h

@@ -0,0 +1,43 @@
+
+// Make sure that we have set the -D flag appropriately.
+#ifdef __SWIFT_ATTR_SUPPORTS_TRANSFERRING
+#if !__SWIFT_ATTR_SUPPORTS_TRANSFERRING
+#error "Compiler should have set __SWIFT_ATTR_SUPPORTS_TRANSFERRING to 1"
+#endif
+#else
+#error "Compiler should have defined __SWIFT_ATTR_SUPPORTS_TRANSFERRING"
+#endif
+
+#define SWIFT_TRANSFERRING __attribute__((swift_attr("transferring")))
+
+#pragma clang assume_nonnull begin
+
+#ifdef __OBJC__
+
+@import Foundation;
+
+@interface MyType : NSObject
+- (NSObject *)getTransferringResult SWIFT_TRANSFERRING;
+- (NSObject *)getTransferringResultWithArgument:(NSObject *)arg SWIFT_TRANSFERRING;
+- (NSObject *)getResultWithTransferringArgument:(NSObject *) SWIFT_TRANSFERRING arg;
+@end
+
+SWIFT_TRANSFERRING
+@interface DoesntMakeSense : NSObject
+@end
+
+NSObject *returnNSObjectFromGlobalFunction(NSObject *other);
+NSObject *transferNSObjectFromGlobalFunction(NSObject *other) SWIFT_TRANSFERRING;
+void transferNSObjectToGlobalFunction(NSObject * arg SWIFT_TRANSFERRING);
+
+#endif
+
+typedef struct {
+  int state;
+} NonSendableCStruct;
+
+NonSendableCStruct returnUserDefinedFromGlobalFunction(NonSendableCStruct other);
+NonSendableCStruct transferUserDefinedFromGlobalFunction(NonSendableCStruct other) SWIFT_TRANSFERRING;
+void transferUserDefinedIntoGlobalFunction(NonSendableCStruct arg SWIFT_TRANSFERRING);
+
+#pragma clang assume_nonnull end

test/ClangImporter/transferring.swift

@@ -0,0 +1,38 @@
+// RUN: %target-swift-frontend -swift-version 6 -disable-availability-checking -emit-sil -o /dev/null %s -parse-as-library -enable-experimental-feature TransferringArgsAndResults -verify -import-objc-header %S/Inputs/transferring.h
+
+// REQUIRES: concurrency
+// REQUIRES: asserts
+
+////////////////////////
+// MARK: Declarations //
+////////////////////////
+
+// Make our non sendable c struct non-Sendable
+@available(*, unavailable)
+extension NonSendableCStruct: Sendable {}
+
+@MainActor func transferToMain<T>(_ t: T) async {}
+func useValue<T>(_ t: T) {}
+
+/////////////////
+// MARK: Tests //
+/////////////////
+
+func funcTestTransferringResult() async {
+  let x = NonSendableCStruct()
+  let y = transferUserDefinedFromGlobalFunction(x)
+  await transferToMain(x)
+  useValue(y)
+
+  // Just to show that without the transferring param, we generate diagnostics.
+  let x2 = NonSendableCStruct()
+  let y2 = returnUserDefinedFromGlobalFunction(x2)
+  await transferToMain(x2) // expected-error {{transferring value of non-Sendable type 'NonSendableCStruct' from nonisolated context to main actor-isolated context}}
+  useValue(y2) // expected-note {{access here could race}}
+}
+
+func funcTestTransferringArg() async {
+  let x = NonSendableCStruct()
+  transferUserDefinedIntoGlobalFunction(x) // expected-error {{binding of non-Sendable type 'NonSendableCStruct' accessed after being transferred}}
+  useValue(x) // expected-note {{access here could race}}
+}

test/ClangImporter/transferring_objc.swift

@@ -0,0 +1,56 @@
+// RUN: %target-swift-frontend -swift-version 6 -disable-availability-checking -emit-sil -o /dev/null %s -parse-as-library -enable-experimental-feature TransferringArgsAndResults -verify -import-objc-header %S/Inputs/transferring.h
+
+// REQUIRES: concurrency
+// REQUIRES: asserts
+// REQUIRES: objc_interop
+
+////////////////////////
+// MARK: Declarations //
+////////////////////////
+
+@MainActor func transferToMain<T>(_ t: T) async {}
+func useValue<T>(_ t: T) {}
+
+/////////////////
+// MARK: Tests //
+/////////////////
+
+func methodTestTransferringResult() async {
+  let x = MyType()
+  let y = x.getTransferringResult()
+  await transferToMain(x)
+  useValue(y)
+}
+
+func methodTestTransferringArg() async {
+  let x = MyType()
+  let s = NSObject()
+  let _ = x.getResultWithTransferringArgument(s)  // expected-error {{binding of non-Sendable type 'NSObject' accessed after being transferred}}
+  useValue(s) // expected-note {{access here could race}}
+}
+
+// Make sure we just ignore the swift_attr if it is applied to something like a
+// class.
+func testDoesntMakeSense() {
+  let _ = DoesntMakeSense()
+}
+
+func funcTestTransferringResult() async {
+  let x = NSObject()
+  let y = transferNSObjectFromGlobalFunction(x)
+  await transferToMain(x)
+  useValue(y)
+
+  // Just to show that without the transferring param, we generate diagnostics.
+  let x2 = NSObject()
+  let y2 = returnNSObjectFromGlobalFunction(x2)
+  await transferToMain(x2) // expected-error {{transferring 'x2' may cause a race}}
+  // expected-note @-1 {{transferring disconnected 'x2' to main actor-isolated callee could cause races in between callee main actor-isolated and local nonisolated uses}}
+  useValue(y2) // expected-note {{access here could race}}
+}
+
+func funcTestTransferringArg() async {
+  let x = NSObject()
+  transferNSObjectToGlobalFunction(x) // expected-error {{binding of non-Sendable type 'NSObject' accessed after being transferred}}
+  useValue(x) // expected-note {{access here could race}}
+}