[Concurrency] Look for explicit 'nonisolated' when getting isolation from protocol conformances.

(cherry picked from commit 4fca62a)

Author: simanerush

lib/Sema/TypeCheckConcurrency.cpp

@@ -5276,13 +5276,26 @@ getIsolationFromConformances(NominalTypeDecl *nominal) {
     }
 
     auto *proto = conformance->getProtocol();
-    switch (auto protoIsolation = getActorIsolation(proto)) {
+    auto inferredIsolation = getInferredActorIsolation(proto);
+    auto protoIsolation = inferredIsolation.isolation;
+    switch (protoIsolation) {
     case ActorIsolation::ActorInstance:
     case ActorIsolation::Unspecified:
-    case ActorIsolation::Nonisolated:
     case ActorIsolation::CallerIsolationInheriting:
     case ActorIsolation::NonisolatedUnsafe:
       break;
+    case ActorIsolation::Nonisolated:
+      if (inferredIsolation.source.kind == IsolationSource::Kind::Explicit) {
+        if (!foundIsolation) {
+          // We found an explicitly 'nonisolated' protocol.
+          foundIsolation = {
+              protoIsolation,
+              IsolationSource(proto, IsolationSource::Conformance)};
+        }
+        continue;
+      } else {
+        break;
+      }
 
     case ActorIsolation::Erased:
       llvm_unreachable("protocol cannot have erased isolation");

test/Concurrency/nonisolated_rules.swift

@@ -63,7 +63,7 @@ public struct PublicNonSendable {
 }
 
 
-nonisolated struct NonisolatedStruct: GloballyIsolated {
+nonisolated struct StructRemovesGlobalActor: GloballyIsolated {
   var x: NonSendable
   var y: Int = 1
 
@@ -106,6 +106,32 @@ struct A: Refined {
   init(x: NonSendable) {
     self.x = x // okay
   }
+
+  init() {
+    self.x = NonSendable()
+  }
+
+  func f() {}
+}
+
+@MainActor protocol ExplicitGlobalActor: Refined {}
+
+struct IsolatedStruct: ExplicitGlobalActor {
+  // expected-note@+2 {{main actor isolation inferred from conformance to protocol 'ExplicitGlobalActor'}}
+  // expected-note@+1 {{calls to instance method 'g()' from outside of its actor context are implicitly asynchronous}}
+  func g() {}
+}
+
+struct NonisolatedStruct {
+  func callF() {
+    return A().f() // okay, 'A' is non-isolated.
+  }
+
+  // expected-note@+1 {{add '@MainActor' to make instance method 'callG()' part of global actor 'MainActor'}}
+  func callG() {
+    // expected-error@+1{{call to main actor-isolated instance method 'g()' in a synchronous nonisolated context}}
+    return IsolatedStruct().g()
+  }
 }
 
 // MARK: - Extensions