[SE-0466] Extensions and members thereof can apply default isolation

Extensions of nonisolated types can get default isolation from context (e.g., @mainactor) independently. This was previously true for members, but not conformances, and recently regressed for members. Fix the logic to consistently allow such extensions to be default main-actor isolated, which affects both their members and conformances. Fixes rdar://156644976.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -6109,6 +6109,23 @@ static bool sendableConformanceRequiresNonisolated(NominalTypeDecl *nominal) {
  return requiresNonisolated;
 }
 
+/// Determine the default isolation for the given declaration context.
+static DefaultIsolation getDefaultIsolationForContext(const DeclContext *dc) {
+ // Check whether there is a file-specific setting.
+ if (auto *sourceFile = dc->getParentSourceFile()) {
+ if (auto defaultIsolationInFile = sourceFile->getDefaultIsolation())
+ return defaultIsolationInFile.value();
+ }
+
+ // If we're in the main module, check the language option.
+ ASTContext &ctx = dc->getASTContext();
+ if (dc->getParentModule() == ctx.MainModule)
+ return ctx.LangOpts.DefaultIsolationBehavior;
+
+ // Otherwise, default to nonisolated.
+ return DefaultIsolation::Nonisolated;
+}
+
 /// Determine the default isolation and isolation source for this declaration,
 /// which may still be overridden by other inference rules.
 static std::tuple<InferredActorIsolation, ValueDecl *,
@@ -6152,12 +6169,27 @@ computeDefaultInferredActorIsolation(ValueDecl *value) {
  return {};
 
  if (dc != dyn_cast<DeclContext>(value)) {
+ // If the nominal type is global-actor-isolated, there's nothing
+ // more to look for.
  if (getActorIsolation(nominal).isMainActor())
  break;
 
- return {};
+ // If this is an extension of a nonisolated type, its isolation
+ // is independent of the type.
+ if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
+ // If there were isolation attributes on the extension, respect
+ // them.
+ if (getIsolationFromAttributes(ext).has_value())
+ return {};
+
+ // Keep looking.
+ } else {
+ // The type is nonisolated, so its members are nonisolated.
+ return {};
+ }
  }
  }
+
  dc = dc->getParent();
  }
 
@@ -6187,12 +6219,8 @@ computeDefaultInferredActorIsolation(ValueDecl *value) {
  return {};
  };
 
- DefaultIsolation defaultIsolation = ctx.LangOpts.DefaultIsolationBehavior;
- if (auto *SF = value->getDeclContext()->getParentSourceFile()) {
- if (auto defaultIsolationInFile = SF->getDefaultIsolation())
- defaultIsolation = defaultIsolationInFile.value();
- }
-
+ DefaultIsolation defaultIsolation =
+ getDefaultIsolationForContext(value->getDeclContext());
  // If we are required to use main actor... just use that.
  if (defaultIsolation == DefaultIsolation::MainActor)
  if (auto result =
@@ -8439,6 +8467,19 @@ ActorIsolation swift::inferConformanceIsolation(
  // isolated to a global actor, we may use the conforming type's isolation.
  auto nominalIsolation = getActorIsolation(nominal);
  if (!nominalIsolation.isGlobalActor()) {
+ // If we are in an extension of the type, we might still infer an
+ // isolated conformance depending on default isolation and on the extension
+ // itself.
+ if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
+ // If there's an isolation-related attribute on the extension, use it.
+ if (auto attrIsolation = getIsolationFromAttributes(ext))
+ return *attrIsolation;
+
+ // If we're defaulting to main-actor isolation, use that.
+ if (getDefaultIsolationForContext(dc) == DefaultIsolation::MainActor)
+ return ActorIsolation::forMainActor(ctx);
+ }
+
  return ActorIsolation::forNonisolated(false);
  }
 

test/Concurrency/assume_mainactor_typechecker_errors.swift

@@ -79,3 +79,24 @@ func testTaskDetached() async {
  await k.doSomething()
  }
 }
+
+// @MainActor
+extension Int {
+ func memberOfInt() { } // expected-note{{calls to instance method 'memberOfInt()' from outside of its actor context are implicitly asynchronous}}
+}
+
+nonisolated func testMemberOfInt(i: Int) {
+ i.memberOfInt() // expected-swift5-warning{{call to main actor-isolated instance method 'memberOfInt()' in a synchronous nonisolated context}}
+ // expected-swift6-error@-1{{call to main actor-isolated instance method 'memberOfInt()' in a synchronous nonisolated context}}
+}
+
+protocol SendableProto: Sendable { }
+
+struct MyStruct: SendableProto { }
+
+extension MyStruct: CustomStringConvertible {
+ var description: String {
+ 17.memberOfInt() // okay, on main actor
+ return "hello"
+ }
+}