[Concurrency] Fix actor-isolation override checking with @asyncHandler.

`@asyncHandler` methods can override with a completely different actor
isolation because they will hop to the appropriate actor themselves.
Therefore, allow differing actor isolation when an `@asyncHandler`
method overrides another method, and don't propagate the actor
isolation from the overridden method to the overriding `@asyncHandler`
method.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -1752,6 +1752,16 @@ static Optional<ActorIsolation> getIsolationFromWitnessedRequirements(
   return std::get<1>(isolatedRequirements.front());
 }
 
+// Check whether a declaration is an asynchronous handler.
+static bool isAsyncHandler(ValueDecl *value) {
+  if (auto func = dyn_cast<AbstractFunctionDecl>(value)) {
+    if (func->isAsyncHandler())
+      return true;
+  }
+
+  return false;
+}
+
 ActorIsolation ActorIsolationRequest::evaluate(
     Evaluator &evaluator, ValueDecl *value) const {
   // If this declaration has one of the actor isolation attributes, report
@@ -1807,15 +1817,19 @@ ActorIsolation ActorIsolationRequest::evaluate(
   // If the declaration overrides another declaration, it must have the same
   // actor isolation.
   if (auto overriddenValue = value->getOverriddenDecl()) {
-    auto isolation = getActorIsolation(overriddenValue);
-    SubstitutionMap subs;
-    if (auto env = value->getInnermostDeclContext()
-            ->getGenericEnvironmentOfContext()) {
-      subs = SubstitutionMap::getOverrideSubstitutions(
-        overriddenValue, value, subs);
-    }
+    // Ignore the overridden declaration's isolation for an async handler,
+    // because async handlers dispatch to wherever they need to be.
+    if (!isAsyncHandler(value)) {
+      auto isolation = getActorIsolation(overriddenValue);
+      SubstitutionMap subs;
+      if (auto env = value->getInnermostDeclContext()
+              ->getGenericEnvironmentOfContext()) {
+        subs = SubstitutionMap::getOverrideSubstitutions(
+          overriddenValue, value, subs);
+      }
 
-    return inferredIsolation(isolation.subst(subs));
+      return inferredIsolation(isolation.subst(subs));
+    }
   }
 
   // If this is an accessor, use the actor isolation of its storage
@@ -1887,6 +1901,10 @@ void swift::checkOverrideActorIsolation(ValueDecl *value) {
   if (!overridden)
     return;
 
+  // Actor isolation doesn't matter for async handlers.
+  if (isAsyncHandler(value))
+    return;
+
   // Determine the actor isolation of this declaration.
   auto isolation = getActorIsolation(value);
 

test/Concurrency/global_actor_inference.swift

@@ -181,6 +181,8 @@ class SuperclassWithGlobalActors {
   @GenericGlobalActor<Int> func f() { }
   @GenericGlobalActor<Int> func g() { } // expected-note{{overridden declaration is here}}
   func h() { }
+  func i() { }
+  func j() { }
 }
 
 @GenericGlobalActor<String>
@@ -190,6 +192,20 @@ class SubclassWithGlobalActors : SuperclassWithGlobalActors {
   @GenericGlobalActor<String> override func g() { } // expected-error{{global actor 'GenericGlobalActor<String>'-isolated instance method 'g()' has different actor isolation from global actor 'GenericGlobalActor<Int>'-isolated overridden declaration}}
 
   override func h() { } // okay: inferred to unspecified
+
+  func onGenericGlobalActorString() { }
+  @GenericGlobalActor<Int> func onGenericGlobalActorInt() { }
+
+  @asyncHandler @GenericGlobalActor<String>
+  override func i() { // okay to differ from superclass because it's an asyncHandler.
+    onGenericGlobalActorString()
+  }
+
+  @asyncHandler
+  override func j() { // okay, isolated to GenericGlobalActor<String>
+    onGenericGlobalActorString() // okay
+    onGenericGlobalActorInt() // expected-error{{call is 'async' but is not marked with 'await'}}
+  }
 }
 
 // ----------------------------------------------------------------------