Address comments

Signed-off-by: Peter Rong <[email protected]>

Author: DataCorrupted

lib/Sema/TypeCheckDecl.cpp

@@ -2569,12 +2569,12 @@ InterfaceTypeRequest::evaluate(Evaluator &eval, ValueDecl *D) const {
       ProtocolDecl *errorProto = Context.getErrorDecl();
       if (thrownTy && !thrownTy->hasError() && errorProto) {
         Type thrownTyInContext = AFD->mapTypeIntoContext(thrownTy);
-        auto thrownTypeRepr = AFD->getThrownTypeRepr();
-        SourceLoc loc =
-            (thrownTypeRepr) ? thrownTypeRepr->getLoc() : AFD->getLoc();
-        if (AFD->getAttrs().hasAttribute<ObjCAttr>()) {
-          Context.Diags.diagnose(loc, diag::typed_thrown_in_objc_forbidden);
-        } else if (!checkConformance(thrownTyInContext, errorProto)) {
+        if (!checkConformance(thrownTyInContext, errorProto)) {
+          SourceLoc loc;
+          if (auto thrownTypeRepr = AFD->getThrownTypeRepr())
+            loc = thrownTypeRepr->getLoc();
+          else
+            loc = AFD->getLoc();
           Context.Diags.diagnose(loc, diag::thrown_type_not_error, thrownTy);
         }
       }

lib/Sema/TypeCheckDeclObjC.cpp

@@ -809,6 +809,24 @@ bool swift::isRepresentableInLanguage(
       return false;
     }
   }
+  auto isTypedThrow = [&]() {
+    // With no AST token this should be `throws`
+    if (!AFD->getThrownTypeRepr())
+      return false;
+    // Or it is a `throws(<ErrorType>)`
+    CanType thrownType = AFD->getThrownInterfaceType()->getCanonicalType();
+    // TODO: only `throws(Error)` is allowed.
+    // Throwing `any MyError` that confronts `Error` is not implemented yet.
+    // Shall we allow `any MyError` in the future, we should check against
+    // `isExistentialType` instead.
+    if (thrownType->isErrorExistentialType())
+      return false;
+    softenIfAccessNote(AFD, Reason.getAttr(),
+                       AFD->diagnose(diag::typed_thrown_in_objc_forbidden)
+                           .limitBehavior(behavior));
+    Reason.describe(AFD);
+    return true;
+  };
 
   if (AFD->hasAsync()) {
     // Asynchronous functions move all of the result value and thrown error
@@ -888,6 +906,8 @@ bool swift::isRepresentableInLanguage(
     // a thrown error.
     std::optional<unsigned> completionHandlerErrorParamIndex;
     if (FD->hasThrows()) {
+      if (isTypedThrow())
+        return false;
       completionHandlerErrorParamIndex = completionHandlerParams.size();
       auto errorType = ctx.getErrorExistentialType();
       addCompletionHandlerParam(OptionalType::get(errorType));
@@ -912,6 +932,9 @@ bool swift::isRepresentableInLanguage(
     SourceLoc throwsLoc;
     Type resultType;
 
+    if (isTypedThrow())
+      return false;
+
     const ConstructorDecl *ctor = nullptr;
     if (auto func = dyn_cast<FuncDecl>(AFD)) {
       resultType = func->getResultInterfaceType();

test/attr/attr_objc.swift

@@ -2268,6 +2268,11 @@ extension Protocol_ObjC1 {
 //===---
 //===--- Error handling
 //===---
+enum ObjCError: Int, Error {
+  case Others
+}
+protocol MyError: Error { }
+
 // CHECK-LABEL: class ClassThrows1
 class ClassThrows1 {
   // CHECK: @objc func methodReturnsVoid() throws
@@ -2329,6 +2334,13 @@ class ClassThrows1 {
 
   // CHECK: {{^}} func fooWithErrorProtocolComposition2(x: any Error & Protocol_ObjC1)
   func fooWithErrorProtocolComposition2(x: Error & Protocol_ObjC1) { }
+
+  @objc func throwsError() throws(Error) {}
+  @objc func throwsMyError() throws(MyError) {}
+  // expected-error@-1{{@objc functions cannot have typed throw}}
+  // expected-error@-2{{thrown type 'any MyError' does not conform to the 'Error' protocol}}
+  @objc func throwsObjCError() throws(ObjCError) {}
+  // expected-error@-1{{@objc functions cannot have typed throw}}
 }
 
 

test/attr/attr_objc_async.swift

@@ -27,6 +27,10 @@ class MyClass {
 
 // actor exporting Objective-C entry points.
 
+enum ObjCError: Int, Error {
+  case Others
+}
+
 // CHECK: actor MyActor
 actor MyActor {
   // CHECK: @objc func doBigJobActor() async -> Int
@@ -49,6 +53,10 @@ actor MyActor {
 
   // CHECK: @objc nonisolated func synchronousGood()
   @objc nonisolated func synchronousGood() { }
+
+  @objc func objcAsyncThrowsError() async throws(Error) -> Void {}
+  @objc func objcAsyncThrowsObjCError() async throws(ObjCError) -> Void {}
+  // expected-error@-1 {{@objc functions cannot have typed throw}}
 }
 
 actor class MyActor2 { }

test/decl/func/typed_throws.swift

@@ -216,13 +216,3 @@ struct NotAnError<T> {}
 
 func badThrowingFunctionType<T>(_: () throws(NotAnError<T>) -> ()) {}
 // expected-error@-1 {{thrown type 'NotAnError<T>' does not conform to the 'Error' protocol}}
-
-enum ObjCError: Int, Error {
-  case Others
-}
-
-import Foundation
-@objc class ObjCClass: NSObject {
-  @objc func objcTypedThrow() throws(ObjCError) -> () {}
-  // expected-error@-1 {{@objc functions cannot have typed throw}}
-}