Centralize Dispatch-related @_unsafe(Sendable|MainActor) hacks

Author: DougGregor

include/swift/AST/Decl.h

@@ -6265,14 +6265,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   Optional<unsigned> findPotentialCompletionHandlerParam(
       const AbstractFunctionDecl *asyncAlternative = nullptr) const;
 
-  /// Determine whether this function is implicitly known to have its
-  /// parameters of function type be @_unsafeSendable.
-  ///
-  /// This hard-codes knowledge of a number of functions that will
-  /// eventually have @_unsafeSendable and, eventually, @Sendable,
-  /// on their parameters of function type.
-  bool hasKnownUnsafeSendableFunctionParams() const;
-
   using DeclContext::operator new;
   using DeclContext::operator delete;
   using Decl::getASTContext;

include/swift/AST/Types.h

@@ -3395,8 +3395,6 @@ struct ParameterListInfo {
   SmallBitVector defaultArguments;
   SmallBitVector acceptsUnlabeledTrailingClosures;
   SmallBitVector propertyWrappers;
-  SmallBitVector unsafeSendable;
-  SmallBitVector unsafeMainActor;
   SmallBitVector implicitSelfCapture;
   SmallBitVector inheritActorContext;
 
@@ -3417,16 +3415,6 @@ struct ParameterListInfo {
   /// property wrapper.
   bool hasExternalPropertyWrapper(unsigned paramIdx) const;
 
-  /// Whether the given parameter is unsafe Sendable, meaning that
-  /// we will treat it as Sendable in a context that has adopted concurrency
-  /// features.
-  bool isUnsafeSendable(unsigned paramIdx) const;
-
-  /// Whether the given parameter is unsafe MainActor, meaning that
-  /// we will treat it as being part of the main actor but that it is not
-  /// part of the type system.
-  bool isUnsafeMainActor(unsigned paramIdx) const;
-
   /// Whether the given parameter is a closure that should allow capture of
   /// 'self' to be implicit, without requiring "self.".
   bool isImplicitSelfCapture(unsigned paramIdx) const;

lib/AST/Decl.cpp

@@ -7733,27 +7733,6 @@ void AbstractFunctionDecl::addDerivativeFunctionConfiguration(
   DerivativeFunctionConfigs->insert(config);
 }
 
-bool AbstractFunctionDecl::hasKnownUnsafeSendableFunctionParams() const {
-  auto nominal = getDeclContext()->getSelfNominalTypeDecl();
-  if (!nominal)
-    return false;
-
-  // DispatchQueue operations.
-  auto nominalName = nominal->getName().str();
-  if (nominalName == "DispatchQueue") {
-    auto name = getBaseName().userFacingName();
-    return llvm::StringSwitch<bool>(name)
-      .Case("sync", true)
-      .Case("async", true)
-      .Case("asyncAndWait", true)
-      .Case("asyncAfter", true)
-      .Case("concurrentPerform", true)
-      .Default(false);
-  }
-
-  return false;
-}
-
 void FuncDecl::setResultInterfaceType(Type type) {
   getASTContext().evaluator.cacheOutput(ResultTypeRequest{this},
                                         std::move(type));

lib/AST/Type.cpp

@@ -928,36 +928,12 @@ static bool allowsUnlabeledTrailingClosureParameter(const ParamDecl *param) {
   return paramType->is<AnyFunctionType>();
 }
 
-/// Determine whether the parameter is contextually Sendable.
-static bool isParamUnsafeSendable(const ParamDecl *param) {
-  // Check for @_unsafeSendable.
-  if (param->getAttrs().hasAttribute<UnsafeSendableAttr>())
-    return true;
-
-  // Check that the parameter is of function type.
-  Type paramType = param->isVariadic() ? param->getVarargBaseTy()
-                                       : param->getInterfaceType();
-  paramType = paramType->getRValueType()->lookThroughAllOptionalTypes();
-  if (!paramType->is<FunctionType>())
-    return false;
-
-  // Check whether this function is known to have @_unsafeSendable function
-  // parameters.
-  auto func = dyn_cast<AbstractFunctionDecl>(param->getDeclContext());
-  if (!func)
-    return false;
-
-  return func->hasKnownUnsafeSendableFunctionParams();
-}
-
 ParameterListInfo::ParameterListInfo(
     ArrayRef<AnyFunctionType::Param> params,
     const ValueDecl *paramOwner,
     bool skipCurriedSelf) {
   defaultArguments.resize(params.size());
   propertyWrappers.resize(params.size());
-  unsafeSendable.resize(params.size());
-  unsafeMainActor.resize(params.size());
   implicitSelfCapture.resize(params.size());
   inheritActorContext.resize(params.size());
 
@@ -1012,14 +988,6 @@ ParameterListInfo::ParameterListInfo(
       propertyWrappers.set(i);
     }
 
-    if (isParamUnsafeSendable(param)) {
-      unsafeSendable.set(i);
-    }
-
-    if (param->getAttrs().hasAttribute<UnsafeMainActorAttr>()) {
-      unsafeMainActor.set(i);
-    }
-
     if (param->getAttrs().hasAttribute<ImplicitSelfCaptureAttr>()) {
       implicitSelfCapture.set(i);
     }
@@ -1045,18 +1013,6 @@ bool ParameterListInfo::hasExternalPropertyWrapper(unsigned paramIdx) const {
   return paramIdx < propertyWrappers.size() ? propertyWrappers[paramIdx] : false;
 }
 
-bool ParameterListInfo::isUnsafeSendable(unsigned paramIdx) const {
-  return paramIdx < unsafeSendable.size()
-      ? unsafeSendable[paramIdx]
-      : false;
-}
-
-bool ParameterListInfo::isUnsafeMainActor(unsigned paramIdx) const {
-  return paramIdx < unsafeMainActor.size()
-      ? unsafeMainActor[paramIdx]
-      : false;
-}
-
 bool ParameterListInfo::isImplicitSelfCapture(unsigned paramIdx) const {
   return paramIdx < implicitSelfCapture.size()
       ? implicitSelfCapture[paramIdx]
@@ -1070,8 +1026,7 @@ bool ParameterListInfo::inheritsActorContext(unsigned paramIdx) const {
 }
 
 bool ParameterListInfo::anyContextualInfo() const {
-  return unsafeSendable.any() || unsafeMainActor.any() ||
-      implicitSelfCapture.any() || inheritActorContext.any();
+  return implicitSelfCapture.any() || inheritActorContext.any();
 }
 
 /// Turn a param list into a symbolic and printable representation that does not

lib/Sema/ConstraintSystem.cpp

@@ -18,6 +18,7 @@
 #include "CSDiagnostics.h"
 #include "TypeChecker.h"
 #include "TypeCheckAvailability.h"
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckType.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -1356,7 +1357,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
         ->castTo<AnyFunctionType>();
     if (!isRequirementOrWitness(locator)) {
       unsigned numApplies = getNumApplications(value, false, functionRefKind);
-      funcType = applyGlobalActorType(funcType, func, useDC, numApplies, false);
+      funcType = adjustFunctionTypeForConcurrency(funcType, func, useDC, numApplies, false);
     }
     auto openedType = openFunctionType(
         funcType, locator, replacements, func->getDeclContext());
@@ -1389,7 +1390,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
     if (!isRequirementOrWitness(locator)) {
       unsigned numApplies = getNumApplications(
           funcDecl, false, functionRefKind);
-      funcType = applyGlobalActorType(
+      funcType = adjustFunctionTypeForConcurrency(
           funcType, funcDecl, useDC, numApplies, false);
     }
 
@@ -1658,18 +1659,6 @@ Type constraints::getDynamicSelfReplacementType(
       ->getMetatypeInstanceType();
 }
 
-/// Determine whether the given name is that of a DispatchQueue operation that
-/// takes a closure to be executed on the queue.
-static bool 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);
-}
-
 /// Determine whether this locator refers to a member of "DispatchQueue.main",
 /// which is a special dispatch queue that executes its work on the main actor.
 static bool isMainDispatchQueueMember(ConstraintLocator *locator) {
@@ -1804,7 +1793,7 @@ ConstraintSystem::getTypeOfMemberReference(
     if (!isRequirementOrWitness(locator)) {
       unsigned numApplies = getNumApplications(
           value, hasAppliedSelf, functionRefKind);
-      funcType = applyGlobalActorType(
+      funcType = adjustFunctionTypeForConcurrency(
           funcType, value, useDC, numApplies,
           isMainDispatchQueueMember(locator));
     }

lib/Sema/TypeCheckConcurrency.cpp

@@ -4056,6 +4056,39 @@ static Type applyUnsafeConcurrencyToParameterType(
                                .withGlobalActor(globalActor));
 }
 
+/// 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);
+}
+
+/// Determine whether this function is implicitly known to have its
+/// parameters of function type be @_unsafeSendable.
+///
+/// This hard-codes knowledge of a number of functions that will
+/// eventually have @_unsafeSendable and, eventually, @Sendable,
+/// on their parameters of function type.
+static bool hasKnownUnsafeSendableFunctionParams(AbstractFunctionDecl *func) {
+  auto nominal = func->getDeclContext()->getSelfNominalTypeDecl();
+  if (!nominal)
+    return false;
+
+  // DispatchQueue operations.
+  auto nominalName = nominal->getName().str();
+  if (nominalName == "DispatchQueue") {
+    auto name = func->getBaseName().userFacingName();
+    return isDispatchQueueOperationName(name);
+  }
+
+  return false;
+}
+
 /// Apply @_unsafeSendable and @_unsafeMainActor to the parameters of the
 /// given function.
 static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
@@ -4079,6 +4112,7 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
   auto typeParams = fnType->getParams();
   auto paramDecls = func->getParameters();
   assert(typeParams.size() == paramDecls->size());
+  bool knownUnsafeParams = hasKnownUnsafeSendableFunctionParams(func);
   for (unsigned index : indices(typeParams)) {
     auto param = typeParams[index];
     auto paramDecl = (*paramDecls)[index];
@@ -4089,12 +4123,11 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
     // application.
     bool isSendable =
         (paramDecl->getAttrs().hasAttribute<UnsafeSendableAttr>() ||
-         func->hasKnownUnsafeSendableFunctionParams()) &&
+         knownUnsafeParams) &&
         inConcurrencyContext;
     bool isMainActor =
         (paramDecl->getAttrs().hasAttribute<UnsafeMainActorAttr>() ||
-         (isMainDispatchQueue &&
-          func->hasKnownUnsafeSendableFunctionParams())) &&
+         (isMainDispatchQueue && knownUnsafeParams)) &&
         (inConcurrencyContext || numApplies >= 1);
 
     if (!isSendable && !isMainActor) {
@@ -4110,7 +4143,6 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
       newTypeParams.append(typeParams.begin(), typeParams.begin() + index);
     }
 
-
     // Transform the parameter type.
     Type newParamType = applyUnsafeConcurrencyToParameterType(
         param.getPlainType(), isSendable, isMainActor);
@@ -4140,7 +4172,7 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
       outerFnType->getParams(), Type(fnType), outerFnType->getExtInfo());
 }
 
-AnyFunctionType *swift::applyGlobalActorType(
+AnyFunctionType *swift::adjustFunctionTypeForConcurrency(
     AnyFunctionType *fnType, ValueDecl *funcOrEnum, DeclContext *dc,
     unsigned numApplies, bool isMainDispatchQueue) {
   // Apply unsafe concurrency features to the given function type.

lib/Sema/TypeCheckConcurrency.h

@@ -306,10 +306,23 @@ enum class SendableCheck {
 Optional<std::pair<CustomAttr *, NominalTypeDecl *>>
 checkGlobalActorAttributes(
     SourceLoc loc, DeclContext *dc, ArrayRef<CustomAttr *> attrs);
-/// Get the explicit global actor specified for a closure.
 
+/// Get the explicit global actor specified for a closure.
 Type getExplicitGlobalActor(ClosureExpr *closure);
 
+/// Adjust the given function type to account for concurrency-specific
+/// attributes whose affect on the type might differ based on context.
+/// This includes adjustments for unsafe parameter attributes like
+/// `@_unsafeSendable` and `@_unsafeMainActor` as well as a global actor
+/// on the declaration itself.
+AnyFunctionType *adjustFunctionTypeForConcurrency(
+    AnyFunctionType *fnType, ValueDecl *funcOrEnum, DeclContext *dc,
+    unsigned numApplies, bool isMainDispatchQueue);
+
+/// 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);
+
 /// Check the correctness of the given Sendable conformance.
 ///
 /// \returns true if an error occurred.

lib/Sema/TypeChecker.h

@@ -1320,13 +1320,6 @@ void checkUnknownAttrRestrictions(
 /// it to later stages.
 void bindSwitchCasePatternVars(DeclContext *dc, CaseStmt *stmt);
 
-/// If the given function has a global actor that should be reflected in
-/// references to its function type from the given declaration context,
-/// update the given function type to include the global actor.
-AnyFunctionType *applyGlobalActorType(
-    AnyFunctionType *fnType, ValueDecl *funcOrEnum, DeclContext *dc,
-    unsigned numApplies, bool isMainDispatchQueue);
-
 /// If \p attr was added by an access note, wraps the error in
 /// \c diag::wrap_invalid_attr_added_by_access_note and limits it as an access
 /// note-related diagnostic should be.