[Clang importer] Import @_unsafeSendable on C function/ObjC method params

Author: DougGregor

lib/ClangImporter/ImportType.cpp

@@ -1711,7 +1711,7 @@ static Type applyToFunctionType(
 }
 
 Type ClangImporter::Implementation::applyParamAttributes(
-    const clang::ParmVarDecl *param, Type type) {
+    const clang::ParmVarDecl *param, Type type, bool &isUnsafeSendable) {
   if (!param->hasAttrs())
     return type;
 
@@ -1748,6 +1748,12 @@ Type ClangImporter::Implementation::applyParamAttributes(
 
       continue;
     }
+
+    // Map @_unsafeSendable.
+    if (swiftAttr->getAttribute() == "@_unsafeSendable") {
+      isUnsafeSendable = true;
+      continue;
+    }
   }
 
   return type;
@@ -1928,7 +1934,8 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
     }
 
     // Apply attributes to the type.
-    swiftParamTy = applyParamAttributes(param, swiftParamTy);
+    bool isUnsafeSendable = false;
+    swiftParamTy = applyParamAttributes(param, swiftParamTy, isUnsafeSendable);
 
     // Figure out the name for this parameter.
     Identifier bodyName = importFullName(param, CurrentVersion)
@@ -1949,6 +1956,7 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
     paramInfo->setSpecifier(ParamSpecifier::Default);
     paramInfo->setInterfaceType(swiftParamTy);
     recordImplicitUnwrapForDecl(paramInfo, isParamTypeImplicitlyUnwrapped);
+    recordUnsafeSendableForDecl(paramInfo, isUnsafeSendable);
     parameters.push_back(paramInfo);
     ++index;
   }
@@ -2426,7 +2434,8 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
     }
 
     // Apply Clang attributes to the parameter type.
-    swiftParamTy = applyParamAttributes(param, swiftParamTy);
+    bool isUnsafeSendable = false;
+    swiftParamTy = applyParamAttributes(param, swiftParamTy, isUnsafeSendable);
 
     // Figure out the name for this parameter.
     Identifier bodyName = importFullName(param, CurrentVersion)
@@ -2450,6 +2459,7 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
     paramInfo->setSpecifier(ParamSpecifier::Default);
     paramInfo->setInterfaceType(swiftParamTy);
     recordImplicitUnwrapForDecl(paramInfo, paramIsIUO);
+    recordUnsafeSendableForDecl(paramInfo, isUnsafeSendable);
 
     // Determine whether we have a default argument.
     if (kind == SpecialMethodKind::Regular ||

lib/ClangImporter/ImporterImpl.h

@@ -683,6 +683,14 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     decl->setImplicitlyUnwrappedOptional(true);
   }
 
+  void recordUnsafeSendableForDecl(ValueDecl *decl, bool isUnsafeSendable) {
+    if (!isUnsafeSendable)
+      return;
+
+    decl->getAttrs().add(
+        new (SwiftContext) UnsafeSendableAttr(/*implicit=*/true));
+  }
+
   /// Retrieve the Clang AST context.
   clang::ASTContext &getClangASTContext() const {
     return Instance->getASTContext();
@@ -833,7 +841,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   void importAttributes(const clang::NamedDecl *ClangDecl, Decl *MappedDecl,
                         const clang::ObjCContainerDecl *NewContext = nullptr);
 
-  Type applyParamAttributes(const clang::ParmVarDecl *param, Type type);
+  Type applyParamAttributes(const clang::ParmVarDecl *param, Type type,
+                            bool &isUnsafeSendable);
 
   /// If we already imported a given decl, return the corresponding Swift decl.
   /// Otherwise, return nullptr.

test/ClangImporter/objc_async.swift

@@ -85,6 +85,7 @@ func testSlowServerOldSchool(slowServer: SlowServer) {
 func testSendable(fn: () -> Void) { // expected-note{{parameter 'fn' is implicitly non-concurrent}}
   doSomethingConcurrently(fn)
   // expected-error@-1{{passing non-concurrent parameter 'fn' to function expecting a @Sendable closure}}
+  doSomethingConcurrentlyButUnsafe(fn) // okay, @Sendable not part of the type
 
   var x = 17
   doSomethingConcurrently {
@@ -94,6 +95,14 @@ func testSendable(fn: () -> Void) { // expected-note{{parameter 'fn' is implicit
   }
 }
 
+func testSendableInAsync() async {
+  var x = 17
+  doSomethingConcurrentlyButUnsafe {
+    x = 42 // expected-error{{mutation of captured var 'x' in concurrently-executing code}}
+  }
+  print(x)
+}
+
 // Check import of attributes
 func globalAsync() async { }
 

test/Inputs/clang-importer-sdk/usr/include/ObjCConcurrency.h

@@ -150,4 +150,8 @@ __attribute__((__swift_attr__("@MainActor(unsafe)")))
 // Do something concurrently, but without escaping.
 void doSomethingConcurrently(__attribute__((noescape)) __attribute__((swift_attr("@Sendable"))) void (^block)(void));
 
+
+
+void doSomethingConcurrentlyButUnsafe(__attribute__((noescape)) __attribute__((swift_attr("@_unsafeSendable"))) void (^block)(void));
+
 #pragma clang assume_nonnull end