[region-isolation] When computing isolation for isolated parameters, use getAnyActor instead of getNominalOrBoundGenericNominal().

This ensures that we can properly compute isolation for generic types that
conform to AnyActor.

I found this by playing with test cases from the previous commit. We would not
find an actor type for the actor instance isolation and would fall back along an
incorrect path.

rdar://128021548

Author: gottesmm

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -192,7 +192,10 @@ class SILIsolationInfo {
         actorInstance(ActorInstance::getForValue(actorInstance)) {
     assert((!actorInstance ||
             (actorIsolation.getKind() == ActorIsolation::ActorInstance &&
-             actorInstance->getType().isAnyActor())) &&
+             actorInstance->getType()
+                 .getASTType()
+                 ->lookThroughAllOptionalTypes()
+                 ->getAnyActor())) &&
            "actorInstance must be an actor if it is non-empty");
   }
 

lib/SILOptimizer/Utils/PartitionUtils.cpp

@@ -113,8 +113,9 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
       auto &self = fas.getSelfArgumentOperand();
       if (fas.getArgumentParameterInfo(self).hasOption(
               SILParameterInfo::Isolated)) {
+        CanType astType = self.get()->getType().getASTType();
         if (auto *nomDecl =
-                self.get()->getType().getNominalOrBoundGenericNominal()) {
+                astType->lookThroughAllOptionalTypes()->getAnyActor()) {
           // TODO: We really should be doing this based off of an Operand. Then
           // we would get the SILValue() for the first element. Today this can
           // only mess up isolation history.
@@ -416,8 +417,8 @@ SILIsolationInfo SILIsolationInfo::get(SILArgument *arg) {
   // Before we do anything further, see if we have an isolated parameter. This
   // handles isolated self and specifically marked isolated.
   if (auto *isolatedArg = fArg->getFunction()->maybeGetIsolatedArgument()) {
-    if (auto *nomDecl =
-        isolatedArg->getType().getNominalOrBoundGenericNominal()) {
+    auto astType = isolatedArg->getType().getASTType();
+    if (auto *nomDecl = astType->lookThroughAllOptionalTypes()->getAnyActor()) {
       return SILIsolationInfo::getActorInstanceIsolated(fArg, isolatedArg,
                                                         nomDecl);
     }

test/Concurrency/transfernonsendable.swift

@@ -15,7 +15,7 @@
 ////////////////////////
 
 /// Classes are always non-sendable, so this is non-sendable
-class NonSendableKlass { // expected-complete-note 48{{}}
+class NonSendableKlass { // expected-complete-note 49{{}}
   // expected-typechecker-only-note @-1 4{{}}
   // expected-tns-note @-2 2{{}}
   var field: NonSendableKlass? = nil
@@ -1698,3 +1698,16 @@ func differentInstanceTest(_ a: MyActor, _ b: MyActor) async {
   await b.useKlass(x) // expected-tns-note {{access can happen concurrently}}
   // expected-complete-warning @-1 {{passing argument of non-sendable type 'NonSendableKlass' into actor-isolated context may introduce data races}}
 }
+
+protocol AssociatedTypeTestProtocol {
+  associatedtype A: Actor
+}
+
+func associatedTypeTestBasic<T: AssociatedTypeTestProtocol>(_: T, _: isolated T.A) {
+}
+
+func associatedTypeTestBasic2<T: AssociatedTypeTestProtocol>(_: T, iso: isolated T.A, x: NonSendableKlass) async {
+  await transferToMain(x) // expected-tns-warning {{sending 'x' risks causing data races}}
+  // expected-tns-note @-1 {{sending 'iso'-isolated 'x' to main actor-isolated global function 'transferToMain' risks causing data races between main actor-isolated and 'iso'-isolated uses}}
+  // expected-complete-warning @-2 {{passing argument of non-sendable type 'NonSendableKlass' into main actor-isolated context may introduce data races}}
+}

test/Distributed/distributed_actor_transfernonsendable.swift

@@ -66,3 +66,19 @@ distributed actor MyDistributedActor {
     }
   }
 }
+
+/////////////////////////////////
+// MARK: Associated Type Tests //
+/////////////////////////////////
+
+protocol AssociatedTypeTestProtocol {
+  associatedtype A: DistributedActor
+}
+
+func associatedTypeTestBasic<T: AssociatedTypeTestProtocol>(_: T, _: isolated T.A) {
+}
+
+func associatedTypeTestBasic2<T: AssociatedTypeTestProtocol>(_: T, iso: isolated T.A, x: NonSendableKlass) async {
+  await transferToMain(x) // expected-error {{sending 'x' risks causing data races}}
+  // expected-note @-1 {{sending 'iso'-isolated 'x' to main actor-isolated global function 'transferToMain' risks causing data races between main actor-isolated and 'iso'-isolated uses}}
+}