Merge pull request #82590 from DougGregor/no-main-actor-when-conforming-to-sendable-6.2

[6.2] [SE-0466 experimental amendment] Don't infer @mainactor on types conforming to Sendable

Author: DougGregor

include/swift/Basic/Features.def

@@ -530,6 +530,10 @@ EXPERIMENTAL_FEATURE(DefaultIsolationPerFile, false)
 /// Enable @_lifetime attribute
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(Lifetimes, true)
 
+/// Disable @MainActor inference when the primary definition of a type conforms
+/// to SendableMetatype (or Sendable).
+EXPERIMENTAL_FEATURE(SendableProhibitsMainActorInference, true)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/FeatureSet.cpp

@@ -127,6 +127,7 @@ UNINTERESTING_FEATURE(MacrosOnImports)
 UNINTERESTING_FEATURE(ExtensibleEnums)
 UNINTERESTING_FEATURE(NonisolatedNonsendingByDefault)
 UNINTERESTING_FEATURE(KeyPathWithMethodMembers)
+UNINTERESTING_FEATURE(SendableProhibitsMainActorInference)
 
 static bool usesFeatureNonescapableTypes(Decl *decl) {
   auto containsNonEscapable =

lib/Sema/DerivedConformance/DerivedConformanceCodable.cpp

@@ -155,14 +155,16 @@ addImplicitCodingKeys(NominalTypeDecl *target,
   enumDecl->setSynthesized();
   enumDecl->setAccess(AccessLevel::Private);
 
-  switch (C.LangOpts.DefaultIsolationBehavior) {
-  case DefaultIsolation::MainActor:
-    enumDecl->getAttrs().add(NonisolatedAttr::createImplicit(C));
-    break;
-
-  case DefaultIsolation::Nonisolated:
-    // Nothing to do.
-    break;
+  if (!C.LangOpts.hasFeature(Feature::SendableProhibitsMainActorInference)) {
+    switch (C.LangOpts.DefaultIsolationBehavior) {
+    case DefaultIsolation::MainActor:
+      enumDecl->getAttrs().add(NonisolatedAttr::createImplicit(C));
+      break;
+
+    case DefaultIsolation::Nonisolated:
+      // Nothing to do.
+      break;
+    }
   }
 
   // For classes which inherit from something Encodable or Decodable, we

lib/Sema/TypeCheckConcurrency.cpp

@@ -5956,6 +5956,65 @@ static void addAttributesForActorIsolation(ValueDecl *value,
     }
 }
 
+/// Determine whether there is a SendableMetatype conformance that requires that the nominal type
+/// be nonisolated (preventing @MainActor inference).
+static bool sendableConformanceRequiresNonisolated(NominalTypeDecl *nominal) {
+  ASTContext &ctx = nominal->getASTContext();
+  if (!ctx.LangOpts.hasFeature(Feature::SendableProhibitsMainActorInference))
+    return false;
+
+  if (isa<ProtocolDecl>(nominal))
+    return false;
+
+  auto sendable = ctx.getProtocol(KnownProtocolKind::Sendable);
+  auto sendableMetatype = ctx.getProtocol(KnownProtocolKind::SendableMetatype);
+  if (!sendableMetatype)
+    return false;
+
+  // Check whether any of the explicit conformances is to a
+  // SendableMetatype-inheriting protocol. We exclude direct conformance to
+  // Sendable here, because a global-actor-isolated type is implicitly Sendable,
+  // and writing Sendable explicitly
+  InvertibleProtocolSet inverses;
+  bool anyObject = false;
+  auto inherited = getDirectlyInheritedNominalTypeDecls(
+      nominal, inverses, anyObject);
+  for (const auto &entry : inherited) {
+    auto proto = dyn_cast<ProtocolDecl>(entry.Item);
+    if (proto && proto != sendable && proto->inheritsFrom(sendableMetatype))
+      return true;
+  }
+
+  // Check for member or extension macros that define conformances to
+  // SendableMetatype-inheriting protocols.
+  bool requiresNonisolated = false;
+  auto checkMacro = [&](MacroRole role, MacroDecl *macro) {
+    if (!macro || requiresNonisolated)
+      return;
+
+    SmallVector<ProtocolDecl *, 2> conformances;
+    macro->getIntroducedConformances(nominal, role, conformances);
+    for (auto proto : conformances) {
+      if (proto == sendableMetatype || proto->inheritsFrom(sendableMetatype)) {
+        requiresNonisolated = true;
+        break;
+      }
+    }
+  };
+
+  nominal->forEachAttachedMacro(
+      MacroRole::Member,
+      [&](CustomAttr * attr, MacroDecl *macro) {
+        checkMacro(MacroRole::Member, macro);
+      });
+  nominal->forEachAttachedMacro(
+      MacroRole::Extension,
+      [&](CustomAttr * attr, MacroDecl *macro) {
+        checkMacro(MacroRole::Extension, macro);
+      });
+  return requiresNonisolated;
+}
+
 /// Determine the default isolation and isolation source for this declaration,
 /// which may still be overridden by other inference rules.
 static std::tuple<InferredActorIsolation, ValueDecl *,
@@ -5975,24 +6034,34 @@ computeDefaultInferredActorIsolation(ValueDecl *value) {
       auto *dc = value->getInnermostDeclContext();
       while (dc && !inActorContext) {
         if (auto *nominal = dc->getSelfNominalTypeDecl()) {
-          inActorContext = nominal->isAnyActor();
+          if (nominal->isAnyActor())
+            return {};
         }
         dc = dc->getParent();
       }
 
-      if (!inActorContext) {
-        // FIXME: deinit should be implicitly MainActor too.
-        if (isa<TypeDecl>(value) || isa<ExtensionDecl>(value) ||
-            isa<AbstractStorageDecl>(value) || isa<FuncDecl>(value) ||
-            isa<ConstructorDecl>(value)) {
+      // If this is or is a non-type member of a nominal type that conforms to a
+      // SendableMetatype-inheriting protocol in its primary definition, disable
+      // @MainActor inference.
+      auto nominalTypeDecl = dyn_cast<NominalTypeDecl>(value);
+      if (!nominalTypeDecl && !isa<TypeDecl>(value)) {
+        nominalTypeDecl = value->getDeclContext()->getSelfNominalTypeDecl();
+      }
+      if (nominalTypeDecl &&
+          sendableConformanceRequiresNonisolated(nominalTypeDecl))
+        return { };
+
+      // FIXME: deinit should be implicitly MainActor too.
+      if (isa<TypeDecl>(value) || isa<ExtensionDecl>(value) ||
+          isa<AbstractStorageDecl>(value) || isa<FuncDecl>(value) ||
+          isa<ConstructorDecl>(value)) {
           // Preconcurrency here is used to stage the diagnostics
           // when users select `@MainActor` default isolation with
           // non-strict concurrency modes (pre Swift 6).
           auto isolation =
               ActorIsolation::forGlobalActor(globalActor)
                   .withPreconcurrency(!ctx.LangOpts.isSwiftVersionAtLeast(6));
           return {{{isolation, {}}, nullptr, {}}};
-        }
       }
 
       return {};

test/Concurrency/assume_mainactor_typechecker_errors_sendablecheck.swift

@@ -0,0 +1,16 @@
+// RUN: %target-swift-frontend -swift-version 5 -emit-sil -default-isolation MainActor %s -verify -verify-additional-prefix swift5- -enable-experimental-feature SendableProhibitsMainActorInference
+// RUN: %target-swift-frontend -swift-version 6 -emit-sil -default-isolation MainActor %s -verify -verify-additional-prefix swift6- -enable-experimental-feature SendableProhibitsMainActorInference
+
+// REQUIRES: swift_feature_SendableProhibitsMainActorInference
+
+// Ensure that a Sendable-conforming protocol suppresses @MainActor inference
+// for a type.
+enum CK: CodingKey {
+  case one
+
+  func f() { }
+}
+
+nonisolated func testCK(x: CK) {
+  x.f() // okay, because CK and CK.f are not @MainActor.
+}

test/Macros/default_main_actor_nonisolated.swift

@@ -0,0 +1,27 @@
+// REQUIRES: swift_swift_parser, executable_test
+
+// RUN: %empty-directory(%t)
+// RUN: %host-build-swift -swift-version 5 -emit-library -o %t/%target-library-name(MacroDefinition) -module-name=MacroDefinition %S/Inputs/syntax_macro_definitions.swift -g -no-toolchain-stdlib-rpath
+
+// Check for errors
+// RUN: %target-swift-frontend -swift-version 5 -typecheck -load-plugin-library %t/%target-library-name(MacroDefinition) %s -I %t -disable-availability-checking -swift-version 6 -default-isolation MainActor -enable-experimental-feature SendableProhibitsMainActorInference
+
+// REQUIRES: swift_feature_SendableProhibitsMainActorInference
+
+@attached(extension, conformances: Sendable)
+macro AddSendable() = #externalMacro(module: "MacroDefinition", type: "SendableMacro")
+
+@AddSendable
+final class SendableClass {
+  var property: Int { 0 }
+
+  func f() { }
+}
+
+nonisolated func acceptSendable<T: Sendable>(_: T) { }
+
+@concurrent func test(sc: SendableClass) async {
+  acceptSendable(sc) // SendableClass is Sendable
+  acceptSendable(\SendableClass.property) // so is its property
+  sc.f() // not on the main actor, so this is okay
+}