[Distributed] Further witness checking cleanup and tests

Author: ktoso

lib/Sema/TypeCheckProtocol.cpp

@@ -3031,12 +3031,12 @@ bool ConformanceChecker::checkActorIsolation(
   if (isDistributed) {
     // Check if the protocol where the requirement originates from
     // is a distributed actor constrained one.
-    auto proto = dyn_cast<ProtocolDecl>(requirement->getDeclContext());
-    if (proto && proto->isDistributedActor()) {
+    if (cast<ProtocolDecl>(requirement->getDeclContext())->isDistributedActor()) {
       // The requirement was declared in a DistributedActor constrained proto.
       //
-      // This means casting up to this `P` won't "strip off" the "distributed-ness"
-      // of the type, and all call-sites will be checking distributed isolation.
+      // This means casting up to this `P` won't "strip off" the
+      // "distributed-ness" of the type, and all call-sites will be checking
+      // distributed isolation.
       //
       // This means that we can actually allow these specific requirements,
       // to be witnessed without the distributed keyword (!), but they won't be
@@ -3052,8 +3052,7 @@ bool ConformanceChecker::checkActorIsolation(
 
       // If the requirement is distributed, we still need to require it on the witness though.
       // We DO allow a non-distributed requirement to be witnessed here though!
-      if (isDistributedDecl(requirement) &&
-          !isDistributedDecl(witness))
+      if (isDistributedDecl(requirement) && !isDistributedDecl(witness))
         missingOptions |= MissingFlags::WitnessDistributed;
     } else {
       // The protocol requirement comes from a normal (non-distributed actor)
@@ -3062,12 +3061,12 @@ bool ConformanceChecker::checkActorIsolation(
 
       // If we're coming from a non-distributed requirement,
       // then the requirement must be 'throws' to accommodate failure.
-      if (!isDistributedDecl(requirement) && !isThrowsDecl(requirement))
+      if (!isThrowsDecl(requirement))
         missingOptions |= MissingFlags::RequirementThrows;
 
-      // If the requirement is distributed, we require a distributed witness
-      if (!isDistributedDecl(witness) &&
-          (isDistributedDecl(requirement) || !missingOptions))
+      // If the witness is distributed, it is able to witness a requirement
+      // only if the requirement is `async throws`.
+      if (!isDistributedDecl(witness) && !missingOptions)
         missingOptions |= MissingFlags::WitnessDistributed;
     }
   }

test/Distributed/distributed_protocol_isolation.swift

@@ -100,8 +100,9 @@ protocol StrictlyLocal {
 
   func localThrows() throws
   // expected-note@-1 2{{mark the protocol requirement 'localThrows()' 'async' to allow actor-isolated conformances}}{{22-22=async }}
-  
-  // TODO: localAsync
+
+  func localAsync() async
+  // expected-note@-1 2{{mark the protocol requirement 'localAsync()' 'throws' to allow actor-isolated conformances}}
 }
 
 distributed actor Nope1_StrictlyLocal: StrictlyLocal {
@@ -111,24 +112,29 @@ distributed actor Nope1_StrictlyLocal: StrictlyLocal {
   func localThrows() throws {}
   // expected-error@-1{{distributed actor-isolated instance method 'localThrows()' cannot be used to satisfy nonisolated protocol requirement}}
   // expected-note@-2{{add 'nonisolated' to 'localThrows()' to make this instance method not isolated to the actor}}
+  func localAsync() async {}
+  // expected-error@-1{{distributed actor-isolated instance method 'localAsync()' cannot be used to satisfy nonisolated protocol requirement}}
+  // expected-note@-2{{add 'nonisolated' to 'localAsync()' to make this instance method not isolated to the actor}}
 }
 distributed actor Nope2_StrictlyLocal: StrictlyLocal {
   distributed func local() {}
   // expected-error@-1{{actor-isolated distributed instance method 'local()' cannot be used to satisfy nonisolated protocol requirement}}
   distributed func localThrows() throws {}
   // expected-error@-1{{actor-isolated distributed instance method 'localThrows()' cannot be used to satisfy nonisolated protocol requirement}}
+  distributed func localAsync() async {}
+  // expected-error@-1{{actor-isolated distributed instance method 'localAsync()' cannot be used to satisfy nonisolated protocol requirement}}
 }
 distributed actor OK_StrictlyLocal: StrictlyLocal {
   nonisolated func local() {}
   nonisolated func localThrows() throws {}
+  nonisolated func localAsync() async {}
 }
 
 protocol Server {
-  func send<Message: Codable>(message: Message) async throws -> String
+  func send<Message: Codable & Sendable>(message: Message) async throws -> String
 }
 actor MyServer : Server {
-  // expected-note@+1{{consider making generic parameter 'Message' conform to the 'Sendable' protocol}} {{29-29=, Sendable}}
-  func send<Message: Codable>(message: Message) throws -> String { "" }  // expected-warning{{non-sendable type 'Message' in parameter of actor-isolated instance method 'send(message:)' satisfying protocol requirement cannot cross actor boundary}}
+  func send<Message: Codable & Sendable>(message: Message) throws -> String { "" } // OK
 }
 
 protocol AsyncThrowsAll {
@@ -140,9 +146,15 @@ actor LocalOK_AsyncThrowsAll: AsyncThrowsAll {
   func maybe(param: String, int: Int) async throws -> Int { 1111 }
 }
 
-actor LocalOK_Implicitly_AsyncThrowsAll: AsyncThrowsAll {
+actor LocalOK_ImplicitlyThrows_AsyncThrowsAll: AsyncThrowsAll {
+  func maybe(param: String, int: Int) async -> Int { 1111 }
+}
+actor LocalOK_ImplicitlyAsync_AsyncThrowsAll: AsyncThrowsAll {
   func maybe(param: String, int: Int) throws -> Int { 1111 }
 }
+actor LocalOK_ImplicitlyThrowsAsync_AsyncThrowsAll: AsyncThrowsAll {
+  func maybe(param: String, int: Int) -> Int { 1111 }
+}
 
 distributed actor Nope1_AsyncThrowsAll: AsyncThrowsAll {
   func maybe(param: String, int: Int) async throws -> Int { 111 }
@@ -226,7 +238,7 @@ func test_watchingDA_erased(da: DA_TerminationWatchingDA) async throws {
   // expected-warning@-2{{no calls to throwing functions occur within 'try' expression}}
 
   let __secretlyKnownToBeLocal = wda
-  await __secretlyKnownToBeLocal.terminated(da: "local calls are okey!") // OK // OK // FIXME(#59356): (the __secretlyKnown is a hack, but the whenLocal crashes now on pending isolation getting with generic actors for closures)
+  await __secretlyKnownToBeLocal.terminated(da: "local calls are okey!") // OK // FIXME(#59356): (the __secretlyKnown is a hack, but the whenLocal crashes now on pending isolation getting with generic actors for closures)
   // FIXME: pending fix of closure isolation checking with actors #59356
   // await wda.whenLocal { __secretlyKnownToBeLocal in
   //   await __secretlyKnownToBeLocal.terminated(da: "local calls are okey!") // OK