[Concurrency] Only infer @asyncHandler for witnesses within actor classes.

Actor classes are by definition new code, so only perform inference of
@asyncHandler from a protocol requirement to witnesses when those
witnesses are within an actor class. This is partly because
@asyncHandler might not have reasonable semantics outside of actor
classes anywhere (where would you execute the detached task?), and
partly because it is a source-compatibility problem due to the
combination of...

1) Inferring @asyncHandler on imported Objective-C protocol methods for
existing protocols,
2) Inferring @asyncHandler from those protocol methods to an existing
method in a class that conforms to that protocol, and
3) Using an API that is now overloaded for both synchronous and
asynchronous callers will end up preferring the asynchronous version,
then fail due to a missing "await".

The individual steps here are all reasonable, but the result is a
source break, so back off on @asyncHandler inference for witnesses
outside of actor classes. New code gets the more-asynchronous behavior
for free.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -110,14 +110,16 @@ bool IsAsyncHandlerRequest::evaluate(
 
   // Are we in a context where inference is possible?
   auto dc = func->getDeclContext();
-  if (!dc->isTypeContext() || !dc->getParentSourceFile() ||
-      isa<ProtocolDecl>(dc) || !func->hasBody())
+  if (!dc->getSelfClassDecl() || !dc->getParentSourceFile() || !func->hasBody())
     return false;
 
   // Is it possible to infer @asyncHandler for this function at all?
   if (!func->canBeAsyncHandler())
     return false;
 
+  if (!dc->getSelfClassDecl()->isActor())
+    return false;
+
   // Add an implicit @asyncHandler attribute and return true. We're done.
   auto addImplicitAsyncHandlerAttr = [&] {
     func->getAttrs().add(new (func->getASTContext()) AsyncHandlerAttr(true));

lib/Sema/TypeCheckProtocol.cpp

@@ -737,18 +737,6 @@ swift::matchWitness(
     }
   }
 
-  // Check for actor-isolation consistency.
-  switch (getActorIsolation(witness)) {
-  case ActorIsolation::ActorInstance:
-    // Actor-isolated witnesses cannot conform to protocol requirements.
-    return RequirementMatch(witness, MatchKind::ActorIsolatedWitness);
-
-  case ActorIsolation::ActorPrivileged:
-  case ActorIsolation::Independent:
-  case ActorIsolation::Unspecified:
-    break;
-  }
-
   // Now finalize the match.
   auto result = finalize(anyRenaming, optionalAdjustments);
   // Check if the requirement's `@differentiable` attributes are satisfied by
@@ -2487,24 +2475,6 @@ diagnoseMatch(ModuleDecl *module, NormalProtocolConformance *conformance,
   case MatchKind::NonObjC:
     diags.diagnose(match.Witness, diag::protocol_witness_not_objc);
     break;
-  case MatchKind::ActorIsolatedWitness: {
-    bool canBeAsyncHandler = false;
-    if (auto witnessFunc = dyn_cast<FuncDecl>(match.Witness)) {
-      canBeAsyncHandler = !witnessFunc->isAsyncHandler() &&
-          witnessFunc->canBeAsyncHandler();
-    }
-    auto diag = match.Witness->diagnose(
-        canBeAsyncHandler ? diag::actor_isolated_witness_could_be_async_handler
-                          : diag::actor_isolated_witness,
-        match.Witness->getDescriptiveKind(), match.Witness->getName());
-
-    if (canBeAsyncHandler) {
-      diag.fixItInsert(
-          match.Witness->getAttributeInsertionLoc(false), "@asyncHandler ");
-    }
-    break;
-  }
-
   case MatchKind::MissingDifferentiableAttr: {
     auto *witness = match.Witness;
     // Emit a note and fix-it showing the missing requirement `@differentiable`
@@ -4367,6 +4337,34 @@ void ConformanceChecker::resolveValueWitnesses() {
         return;
       }
 
+      // Check for actor-isolation consistency.
+      switch (getActorIsolation(witness)) {
+      case ActorIsolation::ActorInstance: {
+        // Actor-isolated witnesses cannot conform to protocol requirements.
+        bool canBeAsyncHandler = false;
+        if (auto witnessFunc = dyn_cast<FuncDecl>(witness)) {
+          canBeAsyncHandler = !witnessFunc->isAsyncHandler() &&
+          witnessFunc->canBeAsyncHandler();
+        }
+        auto diag = witness->diagnose(
+            canBeAsyncHandler
+                ? diag::actor_isolated_witness_could_be_async_handler
+                : diag::actor_isolated_witness,
+            witness->getDescriptiveKind(), witness->getName());
+
+        if (canBeAsyncHandler) {
+          diag.fixItInsert(
+             witness->getAttributeInsertionLoc(false), "@asyncHandler ");
+        }
+        return;
+      }
+
+      case ActorIsolation::ActorPrivileged:
+      case ActorIsolation::Independent:
+      case ActorIsolation::Unspecified:
+        break;
+      }
+
       // Objective-C checking for @objc requirements.
       if (requirement->isObjC() &&
           requirement->getName() == witness->getName() &&

lib/Sema/TypeCheckProtocol.h

@@ -268,9 +268,6 @@ enum class MatchKind : uint8_t {
   /// The witness is explicitly @nonobjc but the requirement is @objc.
   NonObjC,
 
-  /// The witness is part of actor-isolated state.
-  ActorIsolatedWitness,
-
   /// The witness is missing a `@differentiable` attribute from the requirement.
   MissingDifferentiableAttr,
 
@@ -503,7 +500,6 @@ struct RequirementMatch {
     case MatchKind::AsyncConflict:
     case MatchKind::ThrowsConflict:
     case MatchKind::NonObjC:
-    case MatchKind::ActorIsolatedWitness:
     case MatchKind::MissingDifferentiableAttr:
     case MatchKind::EnumCaseWithAssociatedValues:
       return false;
@@ -536,7 +532,6 @@ struct RequirementMatch {
     case MatchKind::AsyncConflict:
     case MatchKind::ThrowsConflict:
     case MatchKind::NonObjC:
-    case MatchKind::ActorIsolatedWitness:
     case MatchKind::MissingDifferentiableAttr:
     case MatchKind::EnumCaseWithAssociatedValues:
       return false;

test/attr/asynchandler.swift

@@ -27,18 +27,13 @@ func asyncHandlerBad3() throws { }
 func asyncHandlerBad4(result: inout Int) { }
 // expected-error@-1{{'inout' parameter is not allowed in '@asyncHandler' function}}
 
-struct X {
+actor class X {
   @asyncHandler func asyncHandlerMethod() { }
 
-  @asyncHandler
-  mutating func asyncHandlerMethodBad1() { }
-  // expected-error@-1{{'@asyncHandler' function cannot be 'mutating'}}{{3-12=}}
-
   @asyncHandler init() { }
   // expected-error@-1{{@asyncHandler may only be used on 'func' declarations}}
 }
 
-
 // Inference of @asyncHandler
 protocol P {
   @asyncHandler func callback()
@@ -50,3 +45,21 @@ extension X: P {
     let _ = await globalAsyncFunction()
  }
 }
+
+class Y: P {
+  // @asyncHandler is not inferred for classes
+
+  func callback() {
+    // expected-note@-1{{add 'async' to function 'callback()' to make it asynchronous}}
+    // expected-note@-2{{add '@asyncHandler' to function 'callback()' to create an implicit asynchronous context}}
+
+    // okay, it's an async context
+    let _ = await globalAsyncFunction() // expected-error{{'async' in a function that does not support concurrency}}
+ }
+}
+
+struct Z {
+  @asyncHandler
+  mutating func asyncHandlerMethodBad1() { }
+  // expected-error@-1{{'@asyncHandler' function cannot be 'mutating'}}{{3-12=}}
+}

test/decl/protocol/special/Actor.swift

@@ -42,7 +42,7 @@ class C1: Actor {
 
 // Method that is not usable as a witness.
 actor class BA1 {
-  func enqueue(partialTask: PartialAsyncTask) { } // expected-error{{invalid redeclaration of synthesized implementation for protocol requirement 'enqueue(partialTask:)'}}
+  func enqueue(partialTask: PartialAsyncTask) { } // expected-note{{actor-isolated instance method 'enqueue(partialTask:)' cannot be used to satisfy a protocol requirement; did you mean to make it an asychronous handler?}}
 }
 
 // Method that isn't part of the main class definition cannot be used to