Simplify APIs for accessing conformance isolation

The NormalProtocolConformance APIs for checking for an explicitly-written
isolation on a conformance were easy to get to, and the real semantic
API was buried in the type checker, leading to some unprincipled
checking. Instead, create a central ProtocolConformance::getIsolation()
to get the (semantic) actor isolation, and let that be the only place
that will access the explicitly-written global actor isolation for a
conformance. Update all call sites appropriately.

Author: DougGregor

include/swift/AST/ProtocolConformance.h

@@ -240,6 +240,14 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
   /// Otherwise a new conformance will be created.
   ProtocolConformance *getCanonicalConformance();
 
+  /// Determine the actor isolation of this conformance.
+  ActorIsolation getIsolation() const;
+
+  /// Determine whether this conformance is isolated to an actor.
+  bool isIsolated() const {
+    return getIsolation().isActorIsolated();
+  }
+
   /// Return true if the conformance has a witness for the given associated
   /// type.
   bool hasTypeWitness(AssociatedTypeDecl *assocType) const;
@@ -529,6 +537,7 @@ class NormalProtocolConformance : public RootProtocolConformance,
 {
   friend class ValueWitnessRequest;
   friend class TypeWitnessRequest;
+  friend class ConformanceIsolationRequest;
 
   /// The protocol being conformed to.
   ProtocolDecl *Protocol;
@@ -573,6 +582,9 @@ class NormalProtocolConformance : public RootProtocolConformance,
 
   void resolveLazyInfo() const;
 
+  /// Set up global actor isolation for this conformance.
+  void setGlobalActorIsolation(Type globalActorType);
+
 public:
   NormalProtocolConformance(Type conformingType, ProtocolDecl *protocol,
                             SourceLoc loc, DeclContext *dc,
@@ -674,16 +686,6 @@ class NormalProtocolConformance : public RootProtocolConformance,
     return getOptions().contains(ProtocolConformanceFlags::Preconcurrency);
   }
 
-  /// Whether this is a global-actor isolated conformance.
-  bool isGlobalActorIsolated() const {
-    return getOptions().contains(
-        ProtocolConformanceFlags::GlobalActorIsolated);
-  }
-
-  TypeExpr *getGlobalActorIsolation() const {
-    return globalActorIsolation;
-  }
-
   /// Retrieve the location of `@preconcurrency`, if there is one and it is
   /// known.
   SourceLoc getPreconcurrencyLoc() const { return PreconcurrencyLoc; }

lib/AST/ProtocolConformance.cpp

@@ -474,6 +474,17 @@ void NormalProtocolConformance::resolveLazyInfo() const {
   loader->finishNormalConformance(mutableThis, LoaderContextData);
 }
 
+void NormalProtocolConformance::setGlobalActorIsolation(Type globalActorType) {
+  ASTContext &ctx = getDeclContext()->getASTContext();
+  if (globalActorIsolation)
+    globalActorIsolation->setType(MetatypeType::get(globalActorType));
+  else
+    globalActorIsolation = TypeExpr::createImplicit(globalActorType, ctx);
+
+  Bits.NormalProtocolConformance.Options |=
+      static_cast<unsigned>(ProtocolConformanceFlags::GlobalActorIsolated);
+}
+
 void NormalProtocolConformance::setLazyLoader(LazyConformanceLoader *loader,
                                               uint64_t contextData) {
   assert(!Loader && "already has a loader");

lib/AST/ProtocolConformanceRef.cpp

@@ -406,7 +406,7 @@ bool ProtocolConformanceRef::forEachIsolatedConformance(
   auto concrete = getConcrete();
   if (auto normal =
           dyn_cast<NormalProtocolConformance>(concrete->getRootConformance())) {
-    if (normal->isGlobalActorIsolated()) {
+    if (normal->isIsolated()) {
       if (body(concrete))
         return true;
     }

lib/AST/TypeCheckRequests.cpp

@@ -1381,7 +1381,18 @@ bool ConformanceIsolationRequest::isCached() const {
   if (!rootNormal)
     return false;
 
-  return rootNormal->isGlobalActorIsolated();
+  if (rootNormal->globalActorIsolation)
+    return true;
+
+  // If we might infer conformance isolation, then we should cache the result.
+  auto dc = rootNormal->getDeclContext();
+  auto nominal = dc->getSelfNominalTypeDecl();
+  if (nominal &&
+      ((isa<ClassDecl>(nominal) && cast<ClassDecl>(nominal)->isActor()) ||
+       nominal->getSemanticAttrs().hasAttribute<NonisolatedAttr>()))
+    return false;
+
+  return true;
 }
 
 //----------------------------------------------------------------------------//

lib/IRGen/GenProto.cpp

@@ -94,11 +94,6 @@
 using namespace swift;
 using namespace irgen;
 
-namespace swift {
-  // FIXME: Move this on to ProtocolConformance?
-  ActorIsolation getConformanceIsolation(ProtocolConformance *conformance);
-}
-
 namespace {
 
 /// A class for computing how to pass arguments to a polymorphic
@@ -2238,10 +2233,11 @@ namespace {
     void addFlags() {
       // Miscellaneous flags.
       if (auto conf = dyn_cast<NormalProtocolConformance>(Conformance)) {
+        auto isolation = conf->getIsolation();
         Flags = Flags.withIsRetroactive(conf->isRetroactive());
         Flags = Flags.withIsSynthesizedNonUnique(conf->isSynthesizedNonUnique());
         Flags = Flags.withIsConformanceOfProtocol(conf->isConformanceOfProtocol());
-        Flags = Flags.withHasGlobalActorIsolation(conf->isGlobalActorIsolated());
+        Flags = Flags.withHasGlobalActorIsolation(isolation.isGlobalActor());
       } else {
         Flags = Flags.withIsRetroactive(false)
                      .withIsSynthesizedNonUnique(false);
@@ -2435,13 +2431,11 @@ namespace {
         return;
 
       auto normal = cast<NormalProtocolConformance>(Conformance);
-      assert(normal->isGlobalActorIsolated());
       auto nominal = normal->getDeclContext()->getSelfNominalTypeDecl();
 
       // Add global actor type.
       auto sig = nominal->getGenericSignatureOfContext();
-      auto isolation = getConformanceIsolation(
-          const_cast<RootProtocolConformance *>(Conformance));
+      auto isolation = Conformance->getIsolation();
       assert(isolation.isGlobalActor());
       Type globalActorType = isolation.getGlobalActor();
       auto globalActorTypeName = IGM.getTypeRef(

lib/Sema/CSDiagnostics.cpp

@@ -9568,7 +9568,7 @@ bool DisallowedIsolatedConformance::diagnoseAsError() {
   emitDiagnostic(diag::isolated_conformance_with_sendable_simple,
                  conformance->getType(),
                  conformance->getProtocol()->getName(),
-                 getConformanceIsolation(conformance));
+                 conformance->getIsolation());
 
   auto selectedOverload = getCalleeOverloadChoiceIfAvailable(getLocator());
   if (!selectedOverload)

lib/Sema/TypeCheckConcurrency.cpp

@@ -7868,8 +7868,9 @@ bool swift::diagnoseNonSendableFromDeinit(
                                 var->getDescriptiveKind(), var->getName());
 }
 
-ActorIsolation swift::getConformanceIsolation(ProtocolConformance *conformance) {
-  ASTContext &ctx = conformance->getDeclContext()->getASTContext();
+ActorIsolation ProtocolConformance::getIsolation() const {
+  ASTContext &ctx = getDeclContext()->getASTContext();
+  auto conformance = const_cast<ProtocolConformance *>(this);
   return evaluateOrDefault(
       ctx.evaluator, ConformanceIsolationRequest{conformance},
       ActorIsolation());
@@ -7882,10 +7883,10 @@ ConformanceIsolationRequest::evaluate(Evaluator &evaluator, ProtocolConformance
   if (!rootNormal)
     return ActorIsolation::forNonisolated(false);
 
-  if (!rootNormal->isGlobalActorIsolated())
+  if (!rootNormal->globalActorIsolation)
     return ActorIsolation::forNonisolated(false);
 
-  auto globalActorTypeExpr = rootNormal->getGlobalActorIsolation();
+  auto globalActorTypeExpr = rootNormal->globalActorIsolation;
   assert(globalActorTypeExpr && "global actor type is out-of-sync");
 
   // If we don't already have a resolved global actor type, resolve it now.
@@ -7945,11 +7946,9 @@ namespace {
       if (!normal)
         return false;
 
-      if (!normal->isGlobalActorIsolated())
-        return false;
-
-      auto conformanceIsolation = getConformanceIsolation(concrete);
-      if (conformanceIsolation == getContextIsolation())
+      auto conformanceIsolation = concrete->getIsolation();
+      if (!conformanceIsolation.isGlobalActor() ||
+          conformanceIsolation == getContextIsolation())
         return true;
 
       badIsolatedConformances.push_back(concrete);
@@ -7966,7 +7965,7 @@ namespace {
       auto firstConformance = badIsolatedConformances.front();
       ctx.Diags.diagnose(
           loc, diag::isolated_conformance_wrong_domain,
-          getConformanceIsolation(firstConformance),
+          firstConformance->getIsolation(),
           firstConformance->getType(),
           firstConformance->getProtocol()->getName(),
           getContextIsolation());

lib/Sema/TypeCheckConcurrency.h

@@ -699,10 +699,6 @@ void introduceUnsafeInheritExecutorReplacements(
 void introduceUnsafeInheritExecutorReplacements(
     const DeclContext *dc, Type base, SourceLoc loc, LookupResult &result);
 
-/// Determine the isolation of the given conformance. This only applies to
-/// the immediate conformance, not any conformances on which it depends.
-ActorIsolation getConformanceIsolation(ProtocolConformance *conformance);
-
 /// Check for correct use of isolated conformances in the given reference.
 ///
 /// This checks that any isolated conformances that occur in the given

lib/Sema/TypeCheckGeneric.cpp

@@ -938,7 +938,7 @@ void TypeChecker::diagnoseRequirementFailure(
             .IsolatedConformanceProto->isSpecificProtocol(
               KnownProtocolKind::SendableMetatype),
           req.getFirstType(),
-          getConformanceIsolation(isolatedConformance));
+          isolatedConformance->getIsolation());
       diagnosticNote = diag::type_does_not_inherit_or_conform_requirement;
       break;
     }

lib/Sema/TypeCheckProtocol.cpp

@@ -2543,7 +2543,7 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
   }
 
   // Complain if the global-actor-isolated conformances are not enabled.
-  if (conformance->isGlobalActorIsolated() &&
+  if (conformance->isIsolated() &&
       !Context.LangOpts.hasFeature(Feature::IsolatedConformances)) {
     Context.Diags.diagnose(
         ComplainLoc, diag::isolated_conformance_experimental_feature);
@@ -3382,18 +3382,20 @@ ConformanceChecker::checkActorIsolation(ValueDecl *requirement,
     }
 
     return std::nullopt;
-  case ActorReferenceResult::EntersActor:
+  case ActorReferenceResult::EntersActor: {
     // If the conformance itself is isolated to the same isolation domain as
     // the witness, treat this as being in the same concurrency domain.
-    if (Conformance->isGlobalActorIsolated() &&
-        refResult.isolation == getConformanceIsolation(Conformance)) {
+    auto conformanceIsolation = Conformance->getIsolation();
+    if (conformanceIsolation.isGlobalActor() &&
+        refResult.isolation == conformanceIsolation) {
       sameConcurrencyDomain = true;
       isIsolatedConformance = true;
     }
 
     // Handled below.
     break;
   }
+  }
 
   // Keep track of what modifiers are missing from the requirement and witness,
   // so we can decide what to diagnose.
@@ -3572,7 +3574,7 @@ ConformanceChecker::checkActorIsolation(ValueDecl *requirement,
     // Another way to address the issue is to mark the conformance as
     // isolated to the global actor or "@preconcurrency".
     if (Conformance->getSourceKind() == ConformanceEntryKind::Explicit &&
-        !Conformance->isGlobalActorIsolated() &&
+        !Conformance->getIsolation().isGlobalActor() &&
         !Conformance->isPreconcurrency() &&
         !suggestedPreconcurrencyOrIsolated &&
         !requirementIsolation.isActorIsolated() &&
@@ -5218,20 +5220,22 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
       }
 
       if (!diagnosedIsolatedConformanceIssue) {
+        auto outerIsolation = conformance->getIsolation();
         bool foundIssue = ProtocolConformanceRef(assocConf)
           .forEachIsolatedConformance(
             [&](ProtocolConformance *isolatedConformance) {
+              auto innerIsolation = isolatedConformance->getIsolation();
+
               // If the conformance we're checking isn't isolated at all, it
               // needs "isolated".
-              if (!conformance->isGlobalActorIsolated()) {
-                auto isolation = getConformanceIsolation(isolatedConformance);
+              if (!outerIsolation.isGlobalActor()) {
                 std::string globalActorStr = "@" +
-                    isolation.getGlobalActor().getString();
+                innerIsolation.getGlobalActor().getString();
                 ctx.Diags.diagnose(
                     conformance->getLoc(),
                     diag::nonisolated_conformance_depends_on_isolated_conformance,
                     typeInContext, conformance->getProtocol()->getName(),
-                    getConformanceIsolation(isolatedConformance),
+                    innerIsolation,
                     isolatedConformance->getType(),
                     isolatedConformance->getProtocol()->getName(),
                     globalActorStr
@@ -5243,8 +5247,6 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
 
               // The conformance is isolated, but we need it to have the same
               // isolation as the other isolated conformance we found.
-              auto outerIsolation = getConformanceIsolation(conformance);
-              auto innerIsolation = getConformanceIsolation(isolatedConformance);
               if (outerIsolation != innerIsolation) {
                 ctx.Diags.diagnose(
                     conformance->getLoc(),