Merge pull request #40560 from DougGregor/conformance-cross-actor-sendable-checks

Author: DougGregor

lib/Sema/TypeCheckProtocol.cpp

@@ -2865,6 +2865,31 @@ static void emitDeclaredHereIfNeeded(DiagnosticEngine &diags,
   diags.diagnose(value, diag::decl_declared_here, value->getName());
 }
 
+/// Determine if the witness can be made implicitly async.
+static bool isValidImplicitAsync(ValueDecl *witness, ValueDecl *requirement) {
+  if (auto witnessFunc = dyn_cast<AbstractFunctionDecl>(witness)) {
+    if (auto requirementFunc = dyn_cast<AbstractFunctionDecl>(requirement)) {
+      return requirementFunc->hasAsync() &&
+          !(witnessFunc->hasThrows() && !requirementFunc->hasThrows());
+    }
+
+    return false;
+  }
+
+  if (auto witnessStorage = dyn_cast<AbstractStorageDecl>(witness)) {
+    if (auto requirementStorage = dyn_cast<AbstractStorageDecl>(requirement)) {
+      auto requirementAccessor = requirementStorage->getEffectfulGetAccessor();
+      if (!requirementAccessor || !requirementAccessor->hasAsync())
+        return false;
+
+      return witnessStorage->isLessEffectfulThan(
+          requirementStorage, EffectKind::Throws);
+    }
+  }
+
+  return false;
+}
+
 bool ConformanceChecker::checkActorIsolation(
     ValueDecl *requirement, ValueDecl *witness) {
   /// Retrieve a concrete witness for Sendable checking.
@@ -2991,9 +3016,15 @@ bool ConformanceChecker::checkActorIsolation(
     // A synchronous actor function can witness an asynchronous protocol
     // requirement, since calls "through" the protocol are always cross-actor,
     // in which case the function becomes implicitly async.
+    //
+    // In this case, we're crossing actor boundaries so we need to
+    // perform Sendable checking.
     if (witnessClass && witnessClass->isActor()) {
-      if (requirementFunc && requirementFunc->hasAsync() &&
-          (requirementFunc->hasThrows() == witnessFunc->hasThrows())) {
+      if (isValidImplicitAsync(witness, requirement)) {
+        diagnoseNonSendableTypesInReference(
+            getConcreteWitness(), DC, witness->getLoc(),
+            ConcurrentReferenceKind::CrossActor);
+
         return false;
       }
     }

test/Concurrency/actor_isolation.swift

@@ -967,13 +967,13 @@ func testCrossActorProtocol<T: P>(t: T) async {
 
 @available(SwiftStdlib 5.1, *)
 protocol Server {
-  func send<Message: Codable>(message: Message) async throws -> String
+  func send<Message: Codable & Sendable>(message: Message) async throws -> String
 }
 
 @available(SwiftStdlib 5.1, *)
 actor MyServer : Server {
   // okay, asynchronously accessed from clients of the protocol
-  func send<Message: Codable>(message: Message) throws -> String { "" }
+  func send<Message: Codable & Sendable>(message: Message) throws -> String { "" }
 }
 
 // ----------------------------------------------------------------------

test/Concurrency/sendable_conformance_checking.swift

@@ -0,0 +1,147 @@
+// RUN: %target-typecheck-verify-swift
+// REQUIRES: concurrency
+
+@available(SwiftStdlib 5.1, *)
+class NotSendable { // expected-note 8{{class 'NotSendable' does not conform to the 'Sendable' protocol}}
+}
+
+@available(SwiftStdlib 5.1, *)
+@available(*, unavailable)
+extension NotSendable: Sendable { }
+
+@available(SwiftStdlib 5.1, *)
+protocol IsolatedWithNotSendableRequirements: Actor {
+  func f() -> NotSendable
+  var prop: NotSendable { get }
+}
+
+// Okay, everything is isolated the same way
+@available(SwiftStdlib 5.1, *)
+actor A1: IsolatedWithNotSendableRequirements {
+  func f() -> NotSendable { NotSendable() }
+  var prop: NotSendable { NotSendable() }
+}
+
+// Okay, sendable checking occurs when calling through the protocol
+// and also inside the bodies.
+@available(SwiftStdlib 5.1, *)
+actor A2: IsolatedWithNotSendableRequirements {
+  nonisolated func f() -> NotSendable { NotSendable() }
+  nonisolated var prop: NotSendable { NotSendable() }
+}
+
+@available(SwiftStdlib 5.1, *)
+protocol AsyncProtocolWithNotSendable {
+  func f() async -> NotSendable
+  var prop: NotSendable { get async }
+}
+
+// Sendable checking required because calls through protocol cross into the
+// actor's domain.
+@available(SwiftStdlib 5.1, *)
+actor A3: AsyncProtocolWithNotSendable {
+  func f() async -> NotSendable { NotSendable() } // expected-warning{{cannot call function returning non-sendable type 'NotSendable' across actors}}
+
+  var prop: NotSendable { // expected-warning{{cannot use property 'prop' with a non-sendable type 'NotSendable' across actors}}
+    get async {
+      NotSendable()
+    }
+  }
+}
+
+// Sendable checking required because calls through protocol cross into the
+// actor's domain.
+@available(SwiftStdlib 5.1, *)
+actor A4: AsyncProtocolWithNotSendable {
+  func f() -> NotSendable { NotSendable() } // expected-warning{{cannot call function returning non-sendable type 'NotSendable' across actors}}
+
+  var prop: NotSendable { // expected-warning{{cannot use property 'prop' with a non-sendable type 'NotSendable' across actors}}
+    get {
+      NotSendable()
+    }
+  }
+}
+
+// Sendable checking not required because we never cross into the actor's
+// domain.
+@available(SwiftStdlib 5.1, *)
+actor A5: AsyncProtocolWithNotSendable {
+  nonisolated func f() async -> NotSendable { NotSendable() }
+
+  nonisolated var prop: NotSendable {
+    get async {
+      NotSendable()
+    }
+  }
+}
+
+// Sendable checking not required because we never cross into the actor's
+// domain.
+@available(SwiftStdlib 5.1, *)
+actor A6: AsyncProtocolWithNotSendable {
+  nonisolated func f() -> NotSendable { NotSendable() }
+
+  nonisolated var prop: NotSendable {
+    get {
+      NotSendable()
+    }
+  }
+}
+
+@available(SwiftStdlib 5.1, *)
+protocol AsyncThrowingProtocolWithNotSendable {
+  func f() async throws -> NotSendable
+  var prop: NotSendable { get async throws }
+}
+
+// Sendable checking required because calls through protocol cross into the
+// actor's domain.
+@available(SwiftStdlib 5.1, *)
+actor A7: AsyncThrowingProtocolWithNotSendable {
+  func f() async -> NotSendable { NotSendable() } // expected-warning{{cannot call function returning non-sendable type 'NotSendable' across actors}}
+
+  var prop: NotSendable { // expected-warning{{cannot use property 'prop' with a non-sendable type 'NotSendable' across actors}}
+    get async {
+      NotSendable()
+    }
+  }
+}
+
+// Sendable checking required because calls through protocol cross into the
+// actor's domain.
+@available(SwiftStdlib 5.1, *)
+actor A8: AsyncThrowingProtocolWithNotSendable {
+  func f() -> NotSendable { NotSendable() } // expected-warning{{cannot call function returning non-sendable type 'NotSendable' across actors}}
+
+  var prop: NotSendable { // expected-warning{{cannot use property 'prop' with a non-sendable type 'NotSendable' across actors}}
+    get {
+      NotSendable()
+    }
+  }
+}
+
+// Sendable checking not required because we never cross into the actor's
+// domain.
+@available(SwiftStdlib 5.1, *)
+actor A9: AsyncThrowingProtocolWithNotSendable {
+  nonisolated func f() async -> NotSendable { NotSendable() }
+
+  nonisolated var prop: NotSendable {
+    get async {
+      NotSendable()
+    }
+  }
+}
+
+// Sendable checking not required because we never cross into the actor's
+// domain.
+@available(SwiftStdlib 5.1, *)
+actor A10: AsyncThrowingProtocolWithNotSendable {
+  nonisolated func f() -> NotSendable { NotSendable() }
+
+  nonisolated var prop: NotSendable {
+    get {
+      NotSendable()
+    }
+  }
+}

test/Distributed/distributed_protocol_isolation.swift

@@ -129,7 +129,7 @@ protocol Server {
   func send<Message: Codable>(message: Message) async throws -> String
 }
 actor MyServer : Server {
-  func send<Message: Codable>(message: Message) throws -> String { "" }  // okay, asynchronously accessed from clients of the protocol
+  func send<Message: Codable>(message: Message) throws -> String { "" }  // expected-warning{{cannot pass argument of non-sendable type 'Message' across actors}}
 }
 
 protocol AsyncThrowsAll {