Make (Raw)ConformanceIsolation requests work on the normal protocol conformance

Reduce the burden on the evaluator's caching mechanism by handling the
unwrapping of a conformance down to its normal protocol conformance
outside of these requests. Thanks, Slava!

Author: DougGregor

include/swift/AST/ProtocolConformance.h

@@ -148,7 +148,7 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
       Kind : bitmax(NumProtocolConformanceKindBits, 8),
 
       /// Whether the "raw" conformance isolation is "inferred", which applies to most conformances.
-      IsRawConformanceInferred : 1,
+      IsRawIsolationInferred : 1,
 
       /// Whether the computed actor isolation is nonisolated.
       IsComputedNonisolated : 1
@@ -205,16 +205,16 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
   ProtocolConformance(ProtocolConformanceKind kind, Type conformingType)
     : ConformingType(conformingType) {
     Bits.ProtocolConformance.Kind = unsigned(kind);
-    Bits.ProtocolConformance.IsRawConformanceInferred = false;
+    Bits.ProtocolConformance.IsRawIsolationInferred = false;
     Bits.ProtocolConformance.IsComputedNonisolated = false;
   }
 
-  bool isRawConformanceInferred() const {
-    return Bits.ProtocolConformance.IsRawConformanceInferred;
+  bool isRawIsolationInferred() const {
+    return Bits.ProtocolConformance.IsRawIsolationInferred;
   }
 
   void setRawConformanceInferred(bool value = true) {
-    Bits.ProtocolConformance.IsRawConformanceInferred = value;
+    Bits.ProtocolConformance.IsRawIsolationInferred = value;
   }
 
   bool isComputedNonisolated() const {

include/swift/AST/TypeCheckRequests.h

@@ -477,7 +477,7 @@ class ConformanceHasEffectRequest :
 
 class RawConformanceIsolationRequest :
     public SimpleRequest<RawConformanceIsolationRequest,
-                         std::optional<ActorIsolation>(ProtocolConformance *),
+                         std::optional<ActorIsolation>(NormalProtocolConformance *),
                          RequestFlags::SeparatelyCached |
                          RequestFlags::SplitCached> {
 public:
@@ -488,7 +488,7 @@ class RawConformanceIsolationRequest :
 
   // Evaluation.
   std::optional<ActorIsolation>
-  evaluate(Evaluator &evaluator, ProtocolConformance *conformance) const;
+  evaluate(Evaluator &evaluator, NormalProtocolConformance *conformance) const;
 
 public:
   // Separate caching.
@@ -499,7 +499,7 @@ class RawConformanceIsolationRequest :
 
 class ConformanceIsolationRequest :
     public SimpleRequest<ConformanceIsolationRequest,
-                         ActorIsolation(ProtocolConformance *),
+                         ActorIsolation(NormalProtocolConformance *),
                          RequestFlags::SeparatelyCached |
                          RequestFlags::SplitCached> {
 public:
@@ -510,7 +510,7 @@ class ConformanceIsolationRequest :
 
   // Evaluation.
   ActorIsolation
-  evaluate(Evaluator &evaluator, ProtocolConformance *conformance) const;
+  evaluate(Evaluator &evaluator, NormalProtocolConformance *conformance) const;
 
 public:
   // Separate caching.

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -407,11 +407,11 @@ SWIFT_REQUEST(TypeChecker, ConformanceHasEffectRequest,
               bool(EffectKind, ProtocolConformanceRef),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, RawConformanceIsolationRequest,
-              std::optional<ActorIsolation>(ProtocolConformance *),
+              std::optional<ActorIsolation>(NormalProtocolConformance *),
               SeparatelyCached | SplitCached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ConformanceIsolationRequest,
-              ActorIsolation(ProtocolConformance *),
+              ActorIsolation(NormalProtocolConformance *),
               SeparatelyCached | SplitCached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResolveTypeRequest,

lib/AST/TypeCheckRequests.cpp

@@ -1378,7 +1378,7 @@ RawConformanceIsolationRequest::getCachedResult() const {
   auto conformance = std::get<0>(getStorage());
 
   // Was actor isolation non-isolated?
-  if (conformance->isRawConformanceInferred())
+  if (conformance->isRawIsolationInferred())
     return std::optional<ActorIsolation>();
 
   ASTContext &ctx = conformance->getDeclContext()->getASTContext();

lib/Sema/TypeCheckConcurrency.cpp

@@ -7979,46 +7979,55 @@ bool swift::diagnoseNonSendableFromDeinit(
 }
 
 std::optional<ActorIsolation> ProtocolConformance::getRawIsolation() const {
+  // Only normal protocol conformances can be isolated.
+  auto rootNormal =
+      dyn_cast<NormalProtocolConformance>(this->getRootConformance());
+  if (!rootNormal)
+    return ActorIsolation::forNonisolated(false);
+
+  if (this != rootNormal)
+    return rootNormal->getRawIsolation();
+
   ASTContext &ctx = getDeclContext()->getASTContext();
-  auto conformance = const_cast<ProtocolConformance *>(this);
+  auto conformance = const_cast<NormalProtocolConformance *>(rootNormal);
   return evaluateOrDefault(
       ctx.evaluator, RawConformanceIsolationRequest{conformance},
       ActorIsolation());
 }
 
 ActorIsolation ProtocolConformance::getIsolation() const {
+  // Only normal protocol conformances can be isolated.
+  auto rootNormal =
+      dyn_cast<NormalProtocolConformance>(this->getRootConformance());
+  if (!rootNormal)
+    return ActorIsolation::forNonisolated(false);
+
+  if (this != rootNormal)
+    return rootNormal->getIsolation();
+
   ASTContext &ctx = getDeclContext()->getASTContext();
-  auto conformance = const_cast<ProtocolConformance *>(this);
+  auto conformance = const_cast<NormalProtocolConformance *>(rootNormal);
   return evaluateOrDefault(
       ctx.evaluator, ConformanceIsolationRequest{conformance},
       ActorIsolation());
 }
 
 std::optional<ActorIsolation>
 RawConformanceIsolationRequest::evaluate(
-    Evaluator &evaluator, ProtocolConformance *conformance
+    Evaluator &evaluator, NormalProtocolConformance *conformance
 ) const {
-  // Only normal protocol conformances can be isolated.
-  auto rootNormal =
-      dyn_cast<NormalProtocolConformance>(conformance->getRootConformance());
-  if (!rootNormal)
-    return ActorIsolation::forNonisolated(false);
-
-  if (conformance != rootNormal)
-    return rootNormal->getRawIsolation();
-
   // If the conformance is explicitly non-isolated, report that.
-  if (rootNormal->getOptions().contains(ProtocolConformanceFlags::Nonisolated))
+  if (conformance->getOptions().contains(ProtocolConformanceFlags::Nonisolated))
     return ActorIsolation::forNonisolated(false);
 
   // If there is an explicitly-specified global actor on the isolation,
   // resolve it and report it.
-  if (auto globalActorTypeExpr = rootNormal->getExplicitGlobalActorIsolation()) {
+  if (auto globalActorTypeExpr = conformance->getExplicitGlobalActorIsolation()) {
     // If we don't already have a resolved global actor type, resolve it now.
     Type globalActorType = globalActorTypeExpr->getInstanceType();
     if (!globalActorType) {
       const auto resolution = TypeResolution::forInterface(
-          rootNormal->getDeclContext(), std::nullopt,
+          conformance->getDeclContext(), std::nullopt,
           /*unboundTyOpener*/ nullptr,
           /*placeholderHandler*/ nullptr,
           /*packElementOpener*/ nullptr);
@@ -8036,9 +8045,9 @@ RawConformanceIsolationRequest::evaluate(
     return ActorIsolation::forGlobalActor(globalActorType);
   }
 
-  auto dc = rootNormal->getDeclContext();
+  auto dc = conformance->getDeclContext();
   ASTContext &ctx = dc->getASTContext();
-  auto proto = rootNormal->getProtocol();
+  auto proto = conformance->getProtocol();
 
   // If the protocol itself is isolated, don't infer isolation for the
   // conformance.
@@ -8052,7 +8061,7 @@ RawConformanceIsolationRequest::evaluate(
     return ActorIsolation::forNonisolated(false);
 
   // @preconcurrency disables isolation inference.
-  if (rootNormal->isPreconcurrency())
+  if (conformance->isPreconcurrency())
     return ActorIsolation::forNonisolated(false);
 
   return std::nullopt;
@@ -8117,25 +8126,15 @@ ActorIsolation swift::inferConformanceIsolation(
 
 ActorIsolation
 ConformanceIsolationRequest::evaluate(
-    Evaluator &evaluator, ProtocolConformance *conformance
+    Evaluator &evaluator, NormalProtocolConformance *conformance
 ) const {
   // If there is raw isolation, use that.
   if (auto rawIsolation = conformance->getRawIsolation())
     return *rawIsolation;
 
   // Otherwise, we may infer isolation.
-
-  // Only normal protocol conformances can be isolated.
-  auto rootNormal =
-      dyn_cast<NormalProtocolConformance>(conformance->getRootConformance());
-  if (!rootNormal)
-    return ActorIsolation::forNonisolated(false);
-
-  if (conformance != rootNormal)
-    return rootNormal->getIsolation();
-
   return inferConformanceIsolation(
-      rootNormal, /*hasKnownIsolatedWitness=*/false);
+      conformance, /*hasKnownIsolatedWitness=*/false);
 }
 
 namespace {