DispatchQueue.(sync|asyncAndWait) don't have @Sendable parameters

The blocking nature of these APIs means that the closures passed to
them do not actually escape the concurrency domain of the caller.
Remove the implicit `@Sendable`.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -4767,14 +4767,15 @@ static Type applyUnsafeConcurrencyToParameterType(
 
 /// Determine whether the given name is that of a DispatchQueue operation that
 /// takes a closure to be executed on the queue.
-bool swift::isDispatchQueueOperationName(StringRef name) {
-  return llvm::StringSwitch<bool>(name)
-    .Case("sync", true)
-    .Case("async", true)
-    .Case("asyncAndWait", true)
-    .Case("asyncAfter", true)
-    .Case("concurrentPerform", true)
-    .Default(false);
+Optional<DispatchQueueOperation>
+swift::isDispatchQueueOperationName(StringRef name) {
+  return llvm::StringSwitch<Optional<DispatchQueueOperation>>(name)
+    .Case("sync", DispatchQueueOperation::Normal)
+    .Case("async", DispatchQueueOperation::Sendable)
+    .Case("asyncAndWait", DispatchQueueOperation::Normal)
+    .Case("asyncAfter", DispatchQueueOperation::Sendable)
+    .Case("concurrentPerform", DispatchQueueOperation::Sendable)
+    .Default(None);
 }
 
 /// Determine whether this function is implicitly known to have its
@@ -4792,7 +4793,17 @@ static bool hasKnownUnsafeSendableFunctionParams(AbstractFunctionDecl *func) {
   auto nominalName = nominal->getName().str();
   if (nominalName == "DispatchQueue") {
     auto name = func->getBaseName().userFacingName();
-    return isDispatchQueueOperationName(name);
+    auto operation = isDispatchQueueOperationName(name);
+    if (!operation)
+      return false;
+
+    switch (*operation) {
+    case DispatchQueueOperation::Normal:
+      return false;
+
+    case DispatchQueueOperation::Sendable:
+      return true;
+    }
   }
 
   return false;

lib/Sema/TypeCheckConcurrency.h

@@ -427,9 +427,17 @@ AnyFunctionType *adjustFunctionTypeForConcurrency(
     llvm::function_ref<bool(const ClosureExpr *)> isolatedByPreconcurrency,
     llvm::function_ref<Type(Type)> openType);
 
+/// Classifies known dispatch queue operations.
+enum class DispatchQueueOperation {
+  /// This is a dispatch operation we know about.
+  Normal,
+  /// The closure passed to this dispatch queue operation should be Sendable.
+  Sendable,
+};
+
 /// Determine whether the given name is that of a DispatchQueue operation that
 /// takes a closure to be executed on the queue.
-bool isDispatchQueueOperationName(StringRef name);
+Optional<DispatchQueueOperation> isDispatchQueueOperationName(StringRef name);
 
 /// Check the correctness of the given Sendable conformance.
 ///

test/Concurrency/dispatch_inference.swift

@@ -27,5 +27,10 @@ func testUnsafeSendableInAsync(queue: DispatchQueue) async {
   queue.async {
     x = 17 // expected-error{{mutation of captured var 'x' in concurrently-executing code}}
   }
+
+  queue.sync {
+    x = 17 // okay
+  }
+
   print(x)
 }