[Isolated conformances] Infer main actor isolation under UnspecifiedMeansMainActorIsolated

When code in the current module defaults to main actor (under SE-0466),
also infer main-actor isolation for protocol conformances of main-actor
isolated types.

Author: DougGregor

lib/AST/TypeCheckRequests.cpp

@@ -1381,6 +1381,11 @@ bool ConformanceIsolationRequest::isCached() const {
   if (!rootNormal)
     return false;
 
+  // We know this is nonisolated.
+  if (rootNormal->getOptions().contains(ProtocolConformanceFlags::Nonisolated))
+    return false;
+
+  // Explicit global actor isolation needs to be checked.
   if (rootNormal->globalActorIsolation)
     return true;
 

lib/AST/TypeRepr.cpp

@@ -151,8 +151,13 @@ SourceLoc TypeRepr::findAttrLoc(TypeAttrKind kind) const {
   while (auto attrTypeRepr = dyn_cast<AttributedTypeRepr>(typeRepr)) {
     for (auto attr : attrTypeRepr->getAttrs()) {
       if (auto typeAttr = attr.dyn_cast<TypeAttribute*>())
-        if (typeAttr->getKind() == kind)
-          return typeAttr->getStartLoc();
+        if (typeAttr->getKind() == kind) {
+          auto startLoc = typeAttr->getStartLoc();
+          if (startLoc.isValid())
+            return startLoc;
+
+          return typeAttr->getAttrLoc();
+        }
     }
 
     typeRepr = attrTypeRepr->getTypeRepr();

lib/Sema/TypeCheckConcurrency.cpp

@@ -7878,37 +7878,56 @@ ActorIsolation ProtocolConformance::getIsolation() const {
 
 ActorIsolation
 ConformanceIsolationRequest::evaluate(Evaluator &evaluator, ProtocolConformance *conformance) const {
+  // Only normal protocol conformances can be isolated.
   auto rootNormal =
       dyn_cast<NormalProtocolConformance>(conformance->getRootConformance());
   if (!rootNormal)
     return ActorIsolation::forNonisolated(false);
 
-  if (!rootNormal->globalActorIsolation)
+  // If the conformance is explicitly non-isolated, report that.
+  if (rootNormal->getOptions().contains(ProtocolConformanceFlags::Nonisolated))
     return ActorIsolation::forNonisolated(false);
 
-  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.
-  Type globalActorType = globalActorTypeExpr->getInstanceType();
-  if (!globalActorType) {
-    const auto resolution = TypeResolution::forInterface(
-        rootNormal->getDeclContext(), std::nullopt,
-        /*unboundTyOpener*/ nullptr,
-        /*placeholderHandler*/ nullptr,
-        /*packElementOpener*/ nullptr);
-    globalActorType = resolution.resolveType(globalActorTypeExpr->getTypeRepr());
-    if (!globalActorType)
-      return ActorIsolation::forNonisolated(false);
+  // If there is an explicitly-specified global actor on the isolation,
+  // resolve it and report it.
+  if (auto globalActorTypeExpr = rootNormal->globalActorIsolation) {
+    // 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,
+          /*unboundTyOpener*/ nullptr,
+          /*placeholderHandler*/ nullptr,
+          /*packElementOpener*/ nullptr);
+      globalActorType = resolution.resolveType(globalActorTypeExpr->getTypeRepr());
+      if (!globalActorType)
+        return ActorIsolation::forNonisolated(false);
+
+      // Cache the resolved type.
+      globalActorTypeExpr->setType(MetatypeType::get(globalActorType));
+    }
+
+    // FIXME: Make sure the type actually is a global actor type, map it into
+    // context, etc.
 
-    // Cache the resolved type.
-    globalActorTypeExpr->setType(MetatypeType::get(globalActorType));
+    return ActorIsolation::forGlobalActor(globalActorType);
   }
 
-  // FIXME: Make sure the type actually is a global actor type, map it into
-  // context, etc.
+  // In a context where we are inferring @MainActor, if the conforming type
+  // is on the main actor, then the conformance is, too.
+  auto dc = rootNormal->getDeclContext();
+  ASTContext &ctx = dc->getASTContext();
+  auto nominal = dc->getSelfNominalTypeDecl();
+  if (ctx.LangOpts.hasFeature(Feature::UnspecifiedMeansMainActorIsolated) &&
+      nominal) {
+    auto nominalIsolation = getActorIsolation(nominal);
+    if (nominalIsolation.isMainActor()) {
+      rootNormal->setGlobalActorIsolation(nominalIsolation.getGlobalActor());
+      return nominalIsolation;
+    }
+  }
 
-  return ActorIsolation::forGlobalActor(globalActorType);
+  return ActorIsolation::forNonisolated(false);
 }
 
 namespace {

lib/Serialization/Serialization.cpp

@@ -1929,10 +1929,7 @@ void Serializer::writeLocalNormalProtocolConformance(
 
   // Figure out the isolation of the conformance.
   Type globalActorType;
-  auto isolation = evaluateOrDefault(
-      getASTContext().evaluator,
-      ConformanceIsolationRequest{conformance}, swift::ActorIsolation());
-  switch (isolation) {
+  switch (auto isolation = conformance->getIsolation()) {
   case swift::ActorIsolation::Unspecified:
   case swift::ActorIsolation::Nonisolated:
     break;

test/Concurrency/isolated_conformance_default_actor.swift

@@ -0,0 +1,40 @@
+// RUN: %target-swift-frontend -typecheck -verify -target %target-swift-5.1-abi-triple -swift-version 6 -enable-experimental-feature IsolatedConformances -enable-experimental-feature UnspecifiedMeansMainActorIsolated %s
+
+// REQUIRES: swift_feature_IsolatedConformances
+// REQUIRES: swift_feature_UnspecifiedMeansMainActorIsolated
+// REQUIRES: concurrency
+
+nonisolated
+protocol P {
+  func f() // expected-note{{mark the protocol requirement 'f()' 'async' to allow actor-isolated conformances}}
+}
+
+class CImplicitMainActorNonisolatedConformance: nonisolated P {
+  func f() { } // error: explicitly nonisolated conformance
+}
+
+
+@MainActor
+class CExplicitMainActor: P {
+  func f() { } // okay! conformance above is isolated
+}
+
+class CImplicitMainActor: P {
+  func f() { } // okay! conformance above is isolated
+}
+
+// expected-note@+2{{add '@preconcurrency' to the 'P' conformance to defer isolation checking to run time}}
+// expected-note@+1{{add '@MainActor' to the 'P' conformance to restrict it to main actor-isolated code}}
+nonisolated class CNonIsolated: P {
+  @MainActor func f() { } // expected-error{{main actor-isolated instance method 'f()' cannot be used to satisfy nonisolated requirement from protocol 'P'}}
+}
+
+func acceptSendablePMeta<T: Sendable & P>(_: T.Type) { }
+
+nonisolated func testConformancesFromNonisolated() {
+  let _: any P = CExplicitMainActor() // expected-error{{main actor-isolated conformance of 'CExplicitMainActor' to 'P' cannot be used in nonisolated context}}
+  let _: any P = CImplicitMainActor() // expected-error{{main actor-isolated conformance of 'CImplicitMainActor' to 'P' cannot be used in nonisolated context}}
+
+  let _: any P = CNonIsolated()
+  let _: any P = CImplicitMainActorNonisolatedConformance()
+}