[Concurrency] Infer protocol isolation from superclass requirements.

Actor isolation on protocols was already inferred from inherited protocols,
but we were missing inference from a required superclass.

Author: hborla

lib/Sema/TypeCheckConcurrency.cpp

@@ -4603,30 +4603,43 @@ getIsolationFromConformances(NominalTypeDecl *nominal) {
 static std::optional<ActorIsolation>
 getIsolationFromInheritedProtocols(ProtocolDecl *protocol) {
   std::optional<ActorIsolation> foundIsolation;
-  for (auto inherited : protocol->getInheritedProtocols()) {
-    switch (auto protoIsolation = getActorIsolation(inherited)) {
+  bool conflict = false;
+
+  auto inferIsolation = [&](ValueDecl *decl) {
+    switch (auto protoIsolation = getActorIsolation(decl)) {
     case ActorIsolation::ActorInstance:
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
     case ActorIsolation::NonisolatedUnsafe:
-      break;
+      return;
 
     case ActorIsolation::Erased:
       llvm_unreachable("protocol cannot have erased isolation");
 
     case ActorIsolation::GlobalActor:
       if (!foundIsolation) {
         foundIsolation = protoIsolation;
-        continue;
+        return;
       }
 
       if (*foundIsolation != protoIsolation)
-        return std::nullopt;
+        conflict = true;
 
-      break;
+      return;
     }
+  };
+
+  for (auto inherited : protocol->getInheritedProtocols()) {
+    inferIsolation(inherited);
   }
 
+  if (auto *superclass = protocol->getSuperclassDecl()) {
+    inferIsolation(superclass);
+  }
+
+  if (conflict)
+    return std::nullopt;
+
   return foundIsolation;
 }
 

test/Concurrency/global_actor_inference_swift6.swift

@@ -2,7 +2,7 @@
 
 // RUN: %target-swift-frontend -swift-version 6 -emit-module -emit-module-path %t/other_global_actor_inference.swiftmodule -module-name other_global_actor_inference -strict-concurrency=complete %S/Inputs/other_global_actor_inference.swift
 
-// RUN: %target-swift-frontend -swift-version 6 -I %t -disable-availability-checking %s -emit-sil -o /dev/null -verify -enable-upcoming-feature GlobalActorIsolatedTypesUsability
+// RUN: %target-swift-frontend -swift-version 6 -I %t -disable-availability-checking %s -emit-sil -o /dev/null -verify
 
 // REQUIRES: concurrency
 
@@ -179,3 +179,37 @@ extension S3 {
   // expected-error@-1{{global actor 'SomeGlobalActor'-isolated instance method 'f()' cannot be used to satisfy main actor-isolated protocol requirement}}
   //expected-note@-2{{add 'nonisolated' to 'f()' to make this instance method not isolated to the actor}}
 }
+
+@MainActor
+func onMain() {}
+
+@MainActor
+class MainActorSuperclass {}
+
+protocol InferMainFromSuperclass: MainActorSuperclass {
+  func f()
+}
+
+class C1: MainActorSuperclass, InferMainFromSuperclass {
+  func f() {
+    onMain() // okay
+  }
+}
+
+protocol InferenceConflictWithSuperclass: MainActorSuperclass, InferSomeGlobalActor {
+  func g()
+  // expected-note@-1 {{mark the protocol requirement 'g()' 'async' to allow actor-isolated conformances}}
+}
+
+
+class C2: MainActorSuperclass, InferenceConflictWithSuperclass {
+//expected-note@-1 {{add '@preconcurrency' to the 'InferenceConflictWithSuperclass' conformance to defer isolation checking to run time}}
+
+  func f() {}
+
+  func g() {}
+  // expected-error@-1 {{main actor-isolated instance method 'g()' cannot be used to satisfy nonisolated protocol requirement}}
+  // expected-note@-2 {{add 'nonisolated' to 'g()' to make this instance method not isolated to the actor}}
+}
+
+