Ensure that distributed functions with typed throws can be called from outside

When calling a distributed function for an actor that might not be local,
the call can throw due to the distributed actor system producing an
error. The function might, independently, also throw. When the
function uses typed throws, we incorrectly treated the call is if it
would always throw the error type specified by the function. This
leads to incorrectly accepting invalid code, and compiler crashes in
SILGen.

The change here is to always mark calls to distributed functions
outside the actor as "implicitly throwing", which makes sure that we
treat the call sites as throwing 'any Error'. The actual handling of
the typed throw (from the local function) and the untyped throw (from
the distributed actor system) occurs in thunk generation in SILGen,
and was already handled correctly.

Fixes rdar://144093249, and undoes the ban introduced by rdar://136467528

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -5634,9 +5634,6 @@ ERROR(distributed_actor_func_unsupported_specifier, none,
 ERROR(distributed_actor_func_variadic, none,
       "cannot declare variadic argument %0 in %kind1",
       (DeclName, const ValueDecl *))
-ERROR(distributed_actor_func_typed_throws, none,
-      "cannot declare distributed function with typed throws",
-      ())
 NOTE(actor_mutable_state,none,
      "mutation of this %0 is only permitted within the actor",
      (DescriptiveDeclKind))

lib/Sema/CSApply.cpp

@@ -8455,8 +8455,7 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
     // let's mark the call as implicitly throwing.
     if (isDistributedThunk(callee, apply->getFn())) {
       auto *FD = cast<AbstractFunctionDecl>(callee.getDecl());
-      if (!FD->hasThrows())
-        apply->setImplicitlyThrows(true);
+      apply->setImplicitlyThrows(true);
     }
 
     solution.setExprTypes(apply);

lib/Sema/TypeCheckConcurrency.cpp

@@ -3515,18 +3515,14 @@ namespace {
         }
 
         return std::make_pair(
-            /*setThrows=*/!afd->hasThrows(),
+            /*setThrows=*/true,
             /*isDistributedThunk=*/true);
       }
 
       if (auto *var = dyn_cast<VarDecl>(decl)) {
         if (var->isDistributed()) {
-          bool explicitlyThrowing = false;
-          if (auto getter = var->getAccessor(swift::AccessorKind::Get)) {
-            explicitlyThrowing = getter->hasThrows();
-          }
           return std::make_pair(
-              /*setThrows*/ !explicitlyThrowing,
+              /*setThrows*/ true,
               /*isDistributedThunk=*/true);
         }
 

lib/Sema/TypeCheckDistributed.cpp

@@ -618,19 +618,6 @@ bool CheckDistributedFunctionRequest::evaluate(
     return true;
   }
 
-  // TODO: rdar://136467591 Currently typed throws were not implemented for distributed methods
-  if (func->hasThrows()) {
-    if (auto thrownError = func->getEffectiveThrownErrorType()) {
-      // Basically we only support throwing `any Error` out of a distributed
-      // function because then the effective error thrown by thunk calls naturally
-      // is correct and the same `any Error`
-      if (thrownError.has_value() &&
-          !(*thrownError)->isEqual(C.getErrorExistentialType())) {
-        func->diagnose(diag::distributed_actor_func_typed_throws);
-      }
-    }
-  }
-
   return false;
 }
 

test/Distributed/distributed_actor_typed_throws.swift

@@ -0,0 +1,75 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %target-swift-frontend -emit-sil -DMAKE_CORRECT %s -o - | %FileCheck %s
+
+// UNSUPPORTED: back_deploy_concurrency
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+import Distributed
+
+typealias DefaultDistributedActorSystem = LocalTestingDistributedActorSystem
+
+distributed actor Foo {
+  distributed func alwaysThrows() throws(FooError) { }
+
+  func alwaysPropagates() throws(FooError) {
+    // okay, produces FooError
+    try alwaysThrows()
+    _ = try value
+  }
+
+  distributed var value: String {
+    get throws(FooError) {
+      throw FooError()
+    }
+  }
+}
+
+struct FooError: Codable, Error { }
+struct RemoteInvocationError: Codable, Error { }
+
+#if !MAKE_CORRECT
+func testBad(foo: Foo) async throws(FooError) {
+  try await foo.alwaysThrows() // expected-error{{thrown expression type 'any Error' cannot be converted to error type 'FooError'}}
+
+  _ = try await foo.value // expected-error{{thrown expression type 'any Error' cannot be converted to error type 'FooError'}}
+}
+
+func testBadDoCatch(foo: Foo) async throws {
+  do {
+    try await foo.alwaysThrows()
+    _ = try await foo.value
+  } catch let error {
+    let _: Int = error // expected-error{{cannot convert value of type 'any Error' to specified type 'Int'}}
+  }
+}
+#endif
+
+// Distributed thunk for calling alwaysThrows() handles the translation.
+// CHECK-LABEL: sil hidden [thunk] [distributed] [ref_adhoc_requirement_witness "$s11Distributed29LocalTestingInvocationDecoderC18decodeNextArgumentxyKSeRzSERzlF"] @$s30distributed_actor_typed_throws3FooC12alwaysThrowsyyYaKFTE
+// CHECK: [[LOCAL_FN:%.*]] = function_ref @$s30distributed_actor_typed_throws3FooC12alwaysThrowsyyAA0E5ErrorVYKF : $@convention(method) (@sil_isolated @guaranteed Foo) -> @error FooError
+// CHECK-NEXT: hop_to_executor [[FOO:%[0-9]+]]
+// CHECK-NEXT: try_apply [[LOCAL_FN]]([[FOO]]) : $@convention(method) (@sil_isolated @guaranteed Foo) -> @error FooError, normal [[NORMAL_BB:bb[0-9]+]], error [[ERROR_BB:bb[0-9]+]]
+// CHECK: [[ERROR_BB]]([[FOO_ERROR:%.*]] : $FooError):
+// CHECK: alloc_existential_box $any Error, $FooError
+// CHECK-NEXT: project_existential_box $FooError
+// CHECK: store [[FOO_ERROR]]
+
+// CHECK-LABEL: sil hidden @$s30distributed_actor_typed_throws8testGood3fooyAA3FooC_tYaKF : $@convention(thin) @async (@guaranteed Foo) -> @error any Error
+func testGood(foo: Foo) async throws {
+  // CHECK: function_ref @$s30distributed_actor_typed_throws3FooC12alwaysThrowsyyYaKFTE : $@convention(method) @async (@guaranteed Foo) -> @error any Error
+  try await foo.alwaysThrows()
+
+  _ = try await foo.value
+}
+
+func testDoCatch(foo: Foo) async throws(FooError) {
+  do {
+    try await foo.alwaysThrows()
+    _ = try await foo.value
+  } catch let error {
+    if let fe = error as? FooError {
+      throw fe
+    }
+  }
+}