[Concurrency] Introduce "unsafe" @sendable and @mainactor parameters.

Introduce the notion of "unsafe" @sendable parameters, indicated by the
hidden @_unsafeSendable parameter attribute. Closure arguments to such
parameters are treated as @sendable within code that has already
adopted concurrency, but are otherwise enert, allowing them to be
applied to existing concurrency-related APIs to smooth the transition
path to concurrency.

Additionally, introduce the notion of an "unsafe" @mainactor closure,
for cases where we have determined that the closure will execute on
the main actor but it (also) isn't part of the type system.

Pattern-match uses of the Dispatch library's DispatchQueue to infer
both kinds of "unsafe" as appropriate, especially (e.g.) matching the pattern

  DispatchQueue.main.async { ... }

to treat the closure as unsafe @sendable and @mainactor, allowing such
existing code to better integrate with concurrency.

Implements rdar://75988966.

Author: DougGregor

include/swift/AST/Attr.def

@@ -637,6 +637,10 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(nonisolated, Nonisolated,
   APIBreakingToAdd | APIStableToRemove,
   112)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(_unsafeSendable, UnsafeSendable,
+  OnParam | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
+  113)
 
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS

include/swift/AST/Decl.h

@@ -6097,8 +6097,17 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// constructor.
   bool hasDynamicSelfResult() const;
 
+
   AbstractFunctionDecl *getAsyncAlternative() 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 Decl::getASTContext;
 };

include/swift/AST/Expr.h

@@ -3811,6 +3811,12 @@ class ClosureExpr : public AbstractClosureExpr {
     SeparatelyTypeChecked,
   };
 
+  /// Bits used to indicate contextual information that is concurrency-specific.
+  enum UnsafeConcurrencyBits {
+    Sendable = 1 << 0,
+    MainActor = 1 << 1
+  };
+
 private:
   /// The attributes attached to the closure.
   DeclAttributes Attributes;
@@ -3825,7 +3831,10 @@ class ClosureExpr : public AbstractClosureExpr {
   /// the CaptureListExpr which would normally maintain this sort of
   /// information about captured variables), we need to have some way to access
   /// this information directly on the ClosureExpr.
-  VarDecl * CapturedSelfDecl;
+  ///
+  /// The integer indicates how the closure is contextually concurrent.
+  llvm::PointerIntPair<VarDecl *, 2, uint8_t>
+      CapturedSelfDeclAndUnsafeConcurrent;
 
   /// The location of the "async", if present.
   SourceLoc AsyncLoc;
@@ -3855,7 +3864,7 @@ class ClosureExpr : public AbstractClosureExpr {
     : AbstractClosureExpr(ExprKind::Closure, Type(), /*Implicit=*/false,
                           discriminator, parent),
       Attributes(attributes), BracketRange(bracketRange),
-      CapturedSelfDecl(capturedSelfDecl),
+      CapturedSelfDeclAndUnsafeConcurrent(capturedSelfDecl, 0),
       AsyncLoc(asyncLoc), ThrowsLoc(throwsLoc), ArrowLoc(arrowLoc),
       InLoc(inLoc),
       ExplicitResultTypeAndBodyState(explicitResultType, BodyState::Parsed),
@@ -3961,7 +3970,27 @@ class ClosureExpr : public AbstractClosureExpr {
 
   /// VarDecl captured by this closure under the literal name \c self , if any.
   VarDecl *getCapturedSelfDecl() const {
-    return CapturedSelfDecl;
+    return CapturedSelfDeclAndUnsafeConcurrent.getPointer();
+  }
+
+  bool isUnsafeSendable() const {
+    return CapturedSelfDeclAndUnsafeConcurrent.getInt() &
+        UnsafeConcurrencyBits::Sendable;
+  }
+
+  bool isUnsafeMainActor() const {
+    return CapturedSelfDeclAndUnsafeConcurrent.getInt() &
+        UnsafeConcurrencyBits::MainActor;
+  }
+
+  void setContextuallyConcurrent(bool sendable, bool forMainActor) {
+    uint8_t bits = 0;
+    if (sendable)
+      bits |= UnsafeConcurrencyBits::Sendable;
+    if (forMainActor)
+      bits |= UnsafeConcurrencyBits::MainActor;
+
+    CapturedSelfDeclAndUnsafeConcurrent.setInt(bits);
   }
 
   /// Get the type checking state of this closure's body.

include/swift/AST/KnownSDKTypes.def

@@ -38,5 +38,6 @@ KNOWN_SDK_TYPE_DECL(ObjectiveC, ObjCBool, StructDecl, 0)
 // TODO(async): These might move to the stdlib module when concurrency is
 // standardized
 KNOWN_SDK_TYPE_DECL(Concurrency, UnsafeContinuation, NominalTypeDecl, 2)
+KNOWN_SDK_TYPE_DECL(Concurrency, MainActor, NominalTypeDecl, 0)
 
 #undef KNOWN_SDK_TYPE_DECL

include/swift/AST/Types.h

@@ -3343,6 +3343,7 @@ struct ParameterListInfo {
   SmallBitVector defaultArguments;
   SmallBitVector acceptsUnlabeledTrailingClosures;
   SmallBitVector propertyWrappers;
+  SmallBitVector unsafeSendable;
 
 public:
   ParameterListInfo() { }
@@ -3361,6 +3362,11 @@ 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;
+
   /// Retrieve the number of non-defaulted parameters.
   unsigned numNonDefaultedParameters() const {
     return defaultArguments.count();

lib/AST/Decl.cpp

@@ -7331,6 +7331,27 @@ 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

@@ -913,12 +913,35 @@ 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());
 
   // No parameter owner means no parameter list means no default arguments
   // - hand back the zeroed bitvector.
@@ -970,6 +993,10 @@ ParameterListInfo::ParameterListInfo(
     if (param->hasAttachedPropertyWrapper()) {
       propertyWrappers.set(i);
     }
+
+    if (isParamUnsafeSendable(param)) {
+      unsafeSendable.set(i);
+    }
   }
 }
 
@@ -988,6 +1015,12 @@ 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;
+}
+
 /// Turn a param list into a symbolic and printable representation that does not
 /// include the types, something like (_:, b:, c:)
 std::string swift::getParamListAsString(ArrayRef<AnyFunctionType::Param> params) {

lib/ClangImporter/ImportDecl.cpp

@@ -8289,35 +8289,6 @@ bool importer::isImportedAsStatic(const clang::OverloadedOperatorKind op) {
   }
 }
 
-Type ClangImporter::Implementation::getMainActorType() {
-  if (MainActorType)
-    return *MainActorType;
-
-  auto finish = [&](Type type) -> Type {
-    MainActorType = type;
-    return type;
-  };
-
-  if (!SwiftContext.LangOpts.EnableExperimentalConcurrency) {
-    return finish(Type());
-  }
-
-  auto module = SwiftContext.getLoadedModule(SwiftContext.Id_Concurrency);
-  if (!module)
-    return finish(Type());
-
-  SmallVector<ValueDecl *, 1> decls;
-  module->lookupValue(
-    SwiftContext.getIdentifier("MainActor"),
-    NLKind::QualifiedLookup, decls);
-  for (auto decl : decls) {
-    if (auto typeDecl = dyn_cast<TypeDecl>(decl))
-      return finish(typeDecl->getDeclaredInterfaceType());
-  }
-
-  return finish(Type());
-}
-
 unsigned ClangImporter::Implementation::getClangSwiftAttrSourceBuffer(
     StringRef attributeText) {
   auto known = ClangSwiftAttrSourceBuffers.find(attributeText);
@@ -8529,7 +8500,7 @@ void ClangImporter::Implementation::importAttributes(
       // point at which to do name lookup for imported entities.
       if (auto isMainActor = isMainActorAttr(SwiftContext, swiftAttr)) {
         bool isUnsafe = *isMainActor;
-        if (Type mainActorType = getMainActorType()) {
+        if (Type mainActorType = SwiftContext.getMainActorType()) {
           auto typeExpr = TypeExpr::createImplicit(mainActorType, SwiftContext);
           auto attr = CustomAttr::create(SwiftContext, SourceLoc(), typeExpr);
           attr->setArgIsUnsafe(isUnsafe);

lib/ClangImporter/ImportType.cpp

@@ -1731,7 +1731,7 @@ Type ClangImporter::Implementation::applyParamAttributes(
 
     // Map the main-actor attribute.
     if (isMainActorAttr(SwiftContext, swiftAttr)) {
-      if (Type mainActor = getMainActorType()) {
+      if (Type mainActor = SwiftContext.getMainActorType()) {
         type = applyToFunctionType(type, [&](ASTExtInfo extInfo) {
           return extInfo.withGlobalActor(mainActor);
         });

lib/ClangImporter/ImporterImpl.h

@@ -405,9 +405,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// Clang arguments used to create the Clang invocation.
   std::vector<std::string> ClangArgs;
 
-  /// The main actor type, populated the first time we look for it.
-  Optional<Type> MainActorType;
-
   /// Mapping from Clang swift_attr attribute text to the Swift source buffer
   /// IDs that contain that attribute text. These are re-used when parsing the
   /// Swift attributes on import.
@@ -818,9 +815,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// Map a Clang identifier name to its imported Swift equivalent.
   StringRef getSwiftNameFromClangName(StringRef name);
 
-  /// Look for the MainActor type in the _Concurrency library.
-  Type getMainActorType();
-
   /// Retrieve the Swift source buffer ID that corresponds to the given
   /// swift_attr attribute text, creating one if necessary.
   unsigned getClangSwiftAttrSourceBuffer(StringRef attributeText);