Merge pull request swiftlang#73602 from gottesmm/pr-22e1094e1247a2340184e3b4795c4037ae10bc3f

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

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/SIL/Verifier/SILVerifier.cpp

@@ -6574,36 +6574,6 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                               })),
             "transferring result means all results are transferring");
 
-    // We should only ever have a single sil_isolated parameter.
-    bool foundIsolatedParameter = false;
-    for (const auto &parameterInfo : FTy->getParameters()) {
-      if (parameterInfo.hasOption(SILParameterInfo::Isolated)) {
-        auto argType = parameterInfo.getArgumentType(F.getModule(),
-                                                     FTy,
-                                                     F.getTypeExpansionContext());
-        if (argType->isOptional())
-          argType = argType->lookThroughAllOptionalTypes()->getCanonicalType();
-
-        auto genericSig = FTy->getInvocationGenericSignature();
-        auto &ctx = F.getASTContext();
-        auto *actorProtocol = ctx.getProtocol(KnownProtocolKind::Actor);
-        auto *anyActorProtocol = ctx.getProtocol(KnownProtocolKind::AnyActor);
-        bool genericTypeWithActorRequirement = llvm::any_of(
-            genericSig.getRequirements(), [&](const Requirement &other) {
-              if (other.getKind() != RequirementKind::Conformance)
-                return false;
-              if (other.getFirstType()->getCanonicalType() != argType)
-                return false;
-              auto *otherProtocol = other.getProtocolDecl();
-              return otherProtocol->inheritsFrom(actorProtocol) ||
-                     otherProtocol->inheritsFrom(anyActorProtocol);
-            });
-        require(argType->isAnyActorType() || genericTypeWithActorRequirement,
-                "Only any actor types can be isolated");
-        require(!foundIsolatedParameter, "Two isolated parameters");
-        foundIsolatedParameter = true;
-      }
-    }
     require(1 >= std::count_if(FTy->getParameters().begin(), FTy->getParameters().end(),
                                [](const SILParameterInfo &parameterInfo) {
                                  return parameterInfo.hasOption(SILParameterInfo::Isolated);
@@ -7014,11 +6984,37 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
   }
 
+  void verifyParentFunctionSILFunctionType(CanSILFunctionType FTy) {
+    bool foundIsolatedParameter = false;
+    for (const auto &parameterInfo : FTy->getParameters()) {
+      if (parameterInfo.hasOption(SILParameterInfo::Isolated)) {
+           auto argType = parameterInfo.getArgumentType(F.getModule(),
+                                                     FTy,
+                                                     F.getTypeExpansionContext());
+
+        if (argType->isOptional())
+          argType = argType->lookThroughAllOptionalTypes()->getCanonicalType();
+
+        auto genericSig = FTy->getInvocationGenericSignature();
+        auto &ctx = F.getASTContext();
+        auto *actorProtocol = ctx.getProtocol(KnownProtocolKind::Actor);
+        auto *anyActorProtocol = ctx.getProtocol(KnownProtocolKind::AnyActor);
+        require(argType->isAnyActorType() ||
+                    genericSig->requiresProtocol(argType, actorProtocol) ||
+                    genericSig->requiresProtocol(argType, anyActorProtocol),
+                "Only any actor types can be isolated");
+        require(!foundIsolatedParameter, "Two isolated parameters");
+        foundIsolatedParameter = true;
+      }
+    }
+  }
+
   void visitSILFunction(SILFunction *F) {
     PrettyStackTraceSILFunction stackTrace("verifying", F);
 
     CanSILFunctionType FTy = F->getLoweredFunctionType();
     verifySILFunctionType(FTy);
+    verifyParentFunctionSILFunctionType(FTy);
 
     SILModule &mod = F->getModule();
     bool embedded = mod.getASTContext().LangOpts.hasFeature(Feature::Embedded);

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}}
+}