Check consistency of isolation of conformances within other conformances

When a protocol conformance somehow depends on an isolated conformance, it
must itself be isolated to the same global actor as the conformance on
which it depends.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -2733,6 +2733,12 @@ ERROR(isolated_conformance_not_global_actor_isolated,none,
 ERROR(isolated_conformance_experimental_feature,none,
       "isolated conformances require experimental feature "
       " 'IsolatedConformances'", ())
+ERROR(nonisolated_conformance_depends_on_isolated_conformance,none,
+      "conformance of %0 to %1 depends on %2 conformance of %3 to %4; mark it as 'isolated'",
+      (Type, DeclName, ActorIsolation, Type, DeclName))
+ERROR(isolated_conformance_mismatch_with_associated_isolation,none,
+      "%0 conformance of %1 to %2 cannot depend on %3 conformance of %4 to %5",
+      (ActorIsolation, Type, DeclName, ActorIsolation, Type, DeclName))
 WARNING(remove_public_import,none,
         "public import of %0 was not used in public declarations or inlinable code",
         (Identifier))

lib/Sema/TypeCheckConcurrency.cpp

@@ -30,6 +30,7 @@
 #include "swift/AST/ImportCache.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/NameLookupRequests.h"
+#include "swift/AST/PackConformance.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/TypeCheckRequests.h"
@@ -7669,3 +7670,56 @@ bool swift::diagnoseNonSendableFromDeinit(
                                 diag::non_sendable_from_deinit,
                                 var->getDescriptiveKind(), var->getName());
 }
+
+bool swift::forEachIsolatedConformance(
+    ProtocolConformanceRef conformance,
+    llvm::function_ref<bool(ProtocolConformance*)> body
+) {
+  if (conformance.isInvalid() || conformance.isAbstract())
+    return false;
+
+  if (conformance.isPack()) {
+    auto pack = conformance.getPack()->getPatternConformances();
+    for (auto conformance : pack) {
+      if (forEachIsolatedConformance(conformance, body))
+        return true;
+    }
+
+    return false;
+  }
+
+  // Is this an isolated conformance?
+  auto concrete = conformance.getConcrete();
+  if (auto normal =
+          dyn_cast<NormalProtocolConformance>(concrete->getRootConformance())) {
+    if (normal->isIsolated()) {
+      if (body(concrete))
+        return true;
+    }
+  }
+
+  // Check conformances that are part of this conformance.
+  auto subMap = concrete->getSubstitutionMap();
+  for (auto conformance : subMap.getConformances()) {
+    if (forEachIsolatedConformance(conformance, body))
+      return true;
+  }
+
+  return false;
+}
+
+ActorIsolation swift::getConformanceIsolation(ProtocolConformance *conformance) {
+  auto rootNormal =
+      dyn_cast<NormalProtocolConformance>(conformance->getRootConformance());
+  if (!rootNormal)
+    return ActorIsolation::forNonisolated(false);
+
+  if (!rootNormal->isIsolated())
+    return ActorIsolation::forNonisolated(false);
+
+  auto nominal = rootNormal->getDeclContext()->getSelfNominalTypeDecl();
+  if (!nominal)
+    return ActorIsolation::forNonisolated(false);
+
+  return getActorIsolation(nominal);
+}

lib/Sema/TypeCheckConcurrency.h

@@ -699,6 +699,19 @@ void introduceUnsafeInheritExecutorReplacements(
 void introduceUnsafeInheritExecutorReplacements(
     const DeclContext *dc, Type base, SourceLoc loc, LookupResult &result);
 
+/// Enumerate all of the isolated conformances in the given conformance.
+/// 
+/// The given `body` will be called on each isolated conformance. If it ever
+/// returns `true`, this function will abort the search and return `true`.
+bool forEachIsolatedConformance(
+    ProtocolConformanceRef conformance, 
+    llvm::function_ref<bool(ProtocolConformance*)> body
+);
+
+/// 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);
+
 } // end namespace swift
 
 namespace llvm {

lib/Sema/TypeCheckProtocol.cpp

@@ -5207,6 +5207,8 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
   if (where.isImplicit())
     return;
 
+  bool diagnosedIsolatedConformanceIssue = false;
+
   conformance->forEachAssociatedConformance(
     [&](Type depTy, ProtocolDecl *proto, unsigned index) {
       auto assocConf = conformance->getAssociatedConformance(depTy, proto);
@@ -5230,6 +5232,50 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
             where.withRefinedAvailability(availability), depTy, replacementTy);
       }
 
+      if (!diagnosedIsolatedConformanceIssue) {
+        bool foundIssue = forEachIsolatedConformance(
+            ProtocolConformanceRef(assocConf),
+            [&](ProtocolConformance *isolatedConformance) {
+              // If the conformance we're checking isn't isolated at all, it
+              // needs "isolated".
+              if (!conformance->isIsolated()) {
+                ctx.Diags.diagnose(
+                    conformance->getLoc(),
+                    diag::nonisolated_conformance_depends_on_isolated_conformance,
+                    typeInContext, conformance->getProtocol()->getName(),
+                    getConformanceIsolation(isolatedConformance),
+                    isolatedConformance->getType(),
+                    isolatedConformance->getProtocol()->getName()
+               ).fixItInsert(conformance->getProtocolNameLoc(), "isolated ");
+
+                return true;
+              }
+
+              // 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(),
+                    diag::isolated_conformance_mismatch_with_associated_isolation,
+                    outerIsolation,
+                    typeInContext, conformance->getProtocol()->getName(),
+                    innerIsolation,
+                    isolatedConformance->getType(),
+                    isolatedConformance->getProtocol()->getName()
+                );
+
+                return true;
+              }
+
+              return false;
+            }
+        );
+
+        diagnosedIsolatedConformanceIssue = foundIssue;
+      }
+
       return false;
     });
 }

test/Concurrency/isolated_conformance.swift

@@ -40,3 +40,41 @@ class CMismatchedIsolation: isolated P {
 class C: isolated P {
   func f() { } // okay
 }
+
+// Associated conformances with isolation
+
+protocol Q {
+  associatedtype A: P
+}
+
+// expected-error@+2{{conformance of 'SMissingIsolation' to 'Q' depends on main actor-isolated conformance of 'C' to 'P'; mark it as 'isolated'}}{{27-27=isolated }}
+@MainActor
+struct SMissingIsolation: Q {
+  typealias A = C
+}
+
+struct PWrapper<T: P>: P {
+  func f() { }
+}
+
+// expected-error@+2{{conformance of 'SMissingIsolationViaWrapper' to 'Q' depends on main actor-isolated conformance of 'C' to 'P'; mark it as 'isolated'}}
+@MainActor
+struct SMissingIsolationViaWrapper: Q {
+  typealias A = PWrapper<C>
+}
+
+@SomeGlobalActor
+class C2: isolated P {
+  func f() { }
+}
+
+@MainActor
+struct S: isolated Q {
+  typealias A = C
+}
+
+// expected-error@+2{{main actor-isolated conformance of 'SMismatchedActors' to 'Q' cannot depend on global actor 'SomeGlobalActor'-isolated conformance of 'C2' to 'P'}}
+@MainActor
+struct SMismatchedActors: isolated Q {
+  typealias A = C2
+}