Concurrency override actor isolation fixes

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,12 +1817,15 @@ ActorIsolation ActorIsolationRequest::evaluate(
   // If the declaration overrides another declaration, it must have the same
   // actor isolation.
   if (auto overriddenValue = value->getOverriddenDecl()) {
-    if (auto isolation = getActorIsolation(overriddenValue)) {
+    // 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);
+          overriddenValue, value, subs);
       }
 
       return inferredIsolation(isolation.subst(subs));
@@ -1888,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

@@ -177,6 +177,37 @@ struct OtherContainer<U> {
   }
 }
 
+class SuperclassWithGlobalActors {
+  @GenericGlobalActor<Int> func f() { }
+  @GenericGlobalActor<Int> func g() { } // expected-note{{overridden declaration is here}}
+  func h() { }
+  func i() { }
+  func j() { }
+}
+
+@GenericGlobalActor<String>
+class SubclassWithGlobalActors : SuperclassWithGlobalActors {
+  override func f() { } // okay: inferred to @GenericGlobalActor<Int>
+
+  @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'}}
+  }
+}
+
 // ----------------------------------------------------------------------
 // Global actor inference for unspecified contexts
 // ----------------------------------------------------------------------

test/Incremental/Verifier/single-file-private/AnyObject.swift

@@ -73,16 +73,9 @@ func lookupOnAnyObject(object: AnyObject) { // expected-provides {{lookupOnAnyOb
 // expected-member {{Swift.CustomStringConvertible.someMethod}}
 // expected-member {{Swift.CustomDebugStringConvertible.someMethod}}
 // expected-member {{Swift.Equatable.someMember}}
-// expected-member{{Swift.CustomDebugStringConvertible.init}}
 // expected-member{{Swift.CVarArg.someMember}}
 // expected-member{{Foundation._KeyValueCodingAndObservingPublishing.someMember}}
-// expected-member{{Swift.Equatable.init}}
-// expected-member{{Swift.Hashable.init}}
-// expected-member{{Swift.CVarArg.init}}
 // expected-member{{Foundation._KeyValueCodingAndObserving.someMember}}
-// expected-member{{Foundation._KeyValueCodingAndObservingPublishing.init}}
 // expected-member{{Swift.CustomDebugStringConvertible.someMember}}
 // expected-member{{Swift.CustomStringConvertible.someMember}}
-// expected-member{{Swift.CustomStringConvertible.init}}
 // expected-member{{Swift.Hashable.someMember}}
-// expected-member{{Foundation._KeyValueCodingAndObserving.init}}