Add @_predatesConcurrency attribute for declarations.

Introduce the `@_predatesConcurrency` attribute, which specifies that a
given declaration existed prior to the introduction of Swift
Concurrency, has been updated to use concurrency features (global
actors, Sendable, etc.), but should retain its pre-concurrency behavior
for clients that have not yet opted into concurrency.

Implement type and actor-isolation adjustments to
`@_predatesConcurrency` declarations to subsume the `@_unsafeMainActor`,
`@_unsafeSendable`, and `@MainActor(unsafe)` use cases. This is the
bulk of the semantic transformations needed for this new attribute,
but is not yet complete.

Part of rdar://84448438.

Author: DougGregor

include/swift/AST/Attr.def

@@ -695,6 +695,12 @@ SIMPLE_DECL_ATTR(_noAllocation, NoAllocation,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   124)
 
+SIMPLE_DECL_ATTR(_predatesConcurrency, PredatesConcurrency,
+  OnFunc | OnConstructor | OnProtocol | OnGenericType | OnVar | OnSubscript |
+  OnEnumElement | UserInaccessible |
+  ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
+  125)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Decl.h

@@ -883,6 +883,9 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   /// but should behave like a top-level declaration. This is used by lldb.
   void setHoisted(bool hoisted = true) { Bits.Decl.Hoisted = hoisted; }
 
+  /// Whether this declaration predates the introduction of concurrency.
+  bool predatesConcurrency() const;
+
 public:
   bool escapedFromIfConfig() const {
     return Bits.Decl.EscapedFromIfConfig;

lib/AST/Decl.cpp

@@ -718,6 +718,11 @@ Optional<CustomAttrNominalPair> Decl::getGlobalActorAttr() const {
                            None);
 }
 
+bool Decl::predatesConcurrency() const {
+  return getAttrs().hasAttribute<PredatesConcurrencyAttr>();
+}
+
+
 Expr *AbstractFunctionDecl::getSingleExpressionBody() const {
   assert(hasSingleExpressionBody() && "Not a single-expression body");
   auto braceStmt = getBody();

lib/Sema/TypeCheckAttr.cpp

@@ -119,6 +119,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(ImplicitSelfCapture)
   IGNORED_ATTR(InheritActorContext)
   IGNORED_ATTR(Isolated)
+  IGNORED_ATTR(PredatesConcurrency)
 #undef IGNORED_ATTR
 
   void visitAlignmentAttr(AlignmentAttr *attr) {

lib/Sema/TypeCheckConcurrency.cpp

@@ -2743,6 +2743,10 @@ static Optional<ActorIsolation> getIsolationFromAttributes(
           diag::global_actor_non_unsafe_init, globalActorType);
     }
 
+    // If the declaration predates concurrency, it has unsafe actor isolation.
+    if (decl->predatesConcurrency())
+      isUnsafe = true;
+
     return ActorIsolation::forGlobalActor(
         globalActorType->mapTypeOutOfContext(), isUnsafe);
   }
@@ -4028,6 +4032,35 @@ static Type applyUnsafeConcurrencyToParameterType(
                                .withGlobalActor(globalActor));
 }
 
+/// Strip concurrency from the type of the given parameter.
+static Type stripConcurrencyFromParameterType(
+    Type paramType, bool dropGlobalActor) {
+  // Look through optionals.
+  if (Type optionalObject = paramType->getOptionalObjectType()) {
+    Type newOptionalObject =
+        stripConcurrencyFromParameterType(optionalObject, dropGlobalActor);
+    if (optionalObject->isEqual(newOptionalObject))
+      return paramType;
+
+    return OptionalType::get(newOptionalObject);
+  }
+
+  // For function types, strip off Sendable and possibly the global actor.
+  if (auto fnType = paramType->getAs<FunctionType>()) {
+    auto extInfo = fnType->getExtInfo().withConcurrent(false);
+    if (dropGlobalActor)
+      extInfo = extInfo.withGlobalActor(Type());
+    auto newFnType = FunctionType::get(
+        fnType->getParams(), fnType->getResult(), extInfo);
+    if (newFnType->isEqual(paramType))
+      return paramType;
+
+    return newFnType;
+  }
+
+  return paramType;
+}
+
 /// 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) {
@@ -4061,8 +4094,8 @@ static bool hasKnownUnsafeSendableFunctionParams(AbstractFunctionDecl *func) {
   return false;
 }
 
-/// Apply @_unsafeSendable and @_unsafeMainActor to the parameters of the
-/// given function.
+/// Adjust a function type for @_unsafeSendable, @_unsafeMainActor, and
+/// @_predatesConcurrency.
 static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
     AnyFunctionType *fnType, ValueDecl *funcOrEnum,
     bool inConcurrencyContext, unsigned numApplies, bool isMainDispatchQueue) {
@@ -4085,6 +4118,9 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
   auto paramDecls = func->getParameters();
   assert(typeParams.size() == paramDecls->size());
   bool knownUnsafeParams = hasKnownUnsafeSendableFunctionParams(func);
+  bool stripConcurrency =
+      funcOrEnum->predatesConcurrency() &&
+      !inConcurrencyContext;
   for (unsigned index : indices(typeParams)) {
     auto param = typeParams[index];
     auto paramDecl = (*paramDecls)[index];
@@ -4093,19 +4129,28 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
     // @MainActor. @Sendable occurs only in concurrency contents, while
     // @MainActor occurs in concurrency contexts or those where we have an
     // application.
-    bool isSendable =
+    bool addSendable =
         (paramDecl->getAttrs().hasAttribute<UnsafeSendableAttr>() ||
          knownUnsafeParams) &&
         inConcurrencyContext;
-    bool isMainActor =
+    bool addMainActor =
         (paramDecl->getAttrs().hasAttribute<UnsafeMainActorAttr>() ||
          (isMainDispatchQueue && knownUnsafeParams)) &&
         (inConcurrencyContext || numApplies >= 1);
+    Type newParamType = param.getPlainType();
+    if (addSendable || addMainActor) {
+      newParamType = applyUnsafeConcurrencyToParameterType(
+        param.getPlainType(), addSendable, addMainActor);
+    } else if (stripConcurrency) {
+      newParamType = stripConcurrencyFromParameterType(
+          param.getPlainType(), numApplies == 0);
+    }
 
-    if (!isSendable && !isMainActor) {
+    if (!newParamType || newParamType->isEqual(param.getPlainType())) {
       // If any prior parameter has changed, record this one.
       if (!newTypeParams.empty())
         newTypeParams.push_back(param);
+
       continue;
     }
 
@@ -4116,8 +4161,6 @@ static AnyFunctionType *applyUnsafeConcurrencyToFunctionType(
     }
 
     // Transform the parameter type.
-    Type newParamType = applyUnsafeConcurrencyToParameterType(
-        param.getPlainType(), isSendable, isMainActor);
     newTypeParams.push_back(param.withType(newParamType));
   }
 

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1505,6 +1505,7 @@ namespace  {
     UNINTERESTING_ATTR(DynamicReplacement)
     UNINTERESTING_ATTR(PrivateImport)
     UNINTERESTING_ATTR(MainType)
+    UNINTERESTING_ATTR(PredatesConcurrency)
 
     // Differentiation-related attributes.
     UNINTERESTING_ATTR(Differentiable)

test/Concurrency/predates_concurrency.swift

@@ -0,0 +1,77 @@
+// RUN: %target-typecheck-verify-swift  -disable-availability-checking
+// REQUIRES: concurrency
+
+@_predatesConcurrency func unsafelySendableClosure(_ closure: @Sendable () -> Void) { }
+
+@_predatesConcurrency func unsafelyMainActorClosure(_ closure: @MainActor () -> Void) { }
+
+@_predatesConcurrency func unsafelyDoEverythingClosure(_ closure: @MainActor @Sendable () -> Void) { }
+
+struct X {
+  @_predatesConcurrency func unsafelyDoEverythingClosure(_ closure: @MainActor @Sendable () -> Void) { }
+}
+
+
+func testInAsync(x: X) async {
+  let _: Int = unsafelySendableClosure // expected-error{{type '(@Sendable () -> Void) -> ()'}}
+  let _: Int = unsafelyMainActorClosure // expected-error{{type '(@MainActor () -> Void) -> ()'}}
+  let _: Int = unsafelyDoEverythingClosure // expected-error{{type '(@MainActor @Sendable () -> Void) -> ()'}}
+  let _: Int = x.unsafelyDoEverythingClosure // expected-error{{type '(@MainActor @Sendable () -> Void) -> ()'}}
+  let _: Int = X.unsafelyDoEverythingClosure // expected-error{{type '(X) -> (@MainActor @Sendable () -> Void) -> ()'}}
+  let _: Int = (X.unsafelyDoEverythingClosure)(x) // expected-error{{type '(@MainActor @Sendable () -> Void) -> ()'}}
+}
+
+func testElsewhere(x: X) {
+  let _: Int = unsafelySendableClosure // expected-error{{type '(() -> Void) -> ()'}}
+  let _: Int = unsafelyMainActorClosure // expected-error{{type '(() -> Void) -> ()'}}
+  let _: Int = unsafelyDoEverythingClosure // expected-error{{type '(() -> Void) -> ()'}}
+  let _: Int = x.unsafelyDoEverythingClosure // expected-error{{type '(() -> Void) -> ()'}}
+  let _: Int = X.unsafelyDoEverythingClosure // expected-error{{type '(X) -> (() -> Void) -> ()'}}
+  let _: Int = (X.unsafelyDoEverythingClosure)(x) // expected-error{{type '(() -> Void) -> ()'}}
+}
+
+@MainActor func onMainActor() { }
+
+@MainActor @_predatesConcurrency func onMainActorAlways() { }
+
+@_predatesConcurrency @MainActor class MyModelClass {
+  func f() { }
+}
+
+func testCalls(x: X) {
+  unsafelyMainActorClosure {
+    onMainActor()
+  }
+
+  unsafelyDoEverythingClosure {
+    onMainActor()
+  }
+
+  x.unsafelyDoEverythingClosure {
+    onMainActor()
+    onMainActorAlways()
+  }
+  (X.unsafelyDoEverythingClosure)(x)( {
+    onMainActor()
+    })
+
+  onMainActorAlways() // okay, haven't adopted concurrency
+
+  let _: () -> Void = onMainActorAlways
+
+  // both okay
+  let c = MyModelClass()
+  c.f()
+}
+
+func testCallsWithAsync() async {
+  onMainActorAlways() // expected-error{{expression is 'async' but is not marked with 'await'}}
+  // expected-note@-1{{calls to global function 'onMainActorAlways()' from outside of its actor context are implicitly asynchronous}}
+
+  let _: () -> Void = onMainActorAlways // expected-error{{converting function value of type '@MainActor () -> ()' to '() -> Void' loses global actor 'MainActor'}}
+
+  let c = MyModelClass() // expected-error{{expression is 'async' but is not marked with 'await'}}
+  // expected-note@-1{{calls to initializer 'init()' from outside of its actor context are implicitly asynchronous}}
+  c.f() // expected-error{{expression is 'async' but is not marked with 'await'}}
+  // expected-note@-1{{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
+}