Implemented strict-yet-compatible throws handling for macros:

- JSFunction/JSSetter now always generate throwing bodies but allow `throws`, `throws(Error)`, or `throws(JSException)` without diagnostics; missing or wrong typed throws get an error + fix-it to insert `throws(JSException)`.
- Shared helpers build throws clauses and propagation notes; setter keeps its own note text.
- JSFunction tests updated to require try in generated bodies, add missing-throws coverage, and adjust wrong-type cases; new missing-throws diagnostic test added. JSSetter tests updated with accepted throws(Error) and wrong-type coverage.
- All macro tests pass: `swift test --package-path ./Plugins/BridgeJS --filter BridgeJSMacrosTests`.

Note: pushing wasn’t possible from here (no remote/credentials).

Author: kateinoigakukun

Plugins/BridgeJS/Sources/BridgeJSMacros/JSFunctionMacro.swift

@@ -40,8 +40,7 @@ extension JSFunctionMacro: BodyMacro {
 
             let effects = functionDecl.signature.effectSpecifiers
             let isAsync = effects?.asyncSpecifier != nil
-            let isThrows = effects?.throwsClause != nil
-            let prefix = JSMacroHelper.tryAwaitPrefix(isAsync: isAsync, isThrows: isThrows)
+            let prefix = JSMacroHelper.tryAwaitPrefix(isAsync: isAsync, isThrows: true)
 
             let isVoid = JSMacroHelper.isVoidReturn(functionDecl.signature.returnClause?.type)
             let line = isVoid ? "\(prefix)\(call)" : "return \(prefix)\(call)"
@@ -80,8 +79,7 @@ extension JSFunctionMacro: BodyMacro {
 
             let effects = initializerDecl.signature.effectSpecifiers
             let isAsync = effects?.asyncSpecifier != nil
-            let isThrows = effects?.throwsClause != nil
-            let prefix = JSMacroHelper.tryAwaitPrefix(isAsync: isAsync, isThrows: isThrows)
+            let prefix = JSMacroHelper.tryAwaitPrefix(isAsync: isAsync, isThrows: true)
 
             return [
                 CodeBlockItemSyntax(stringLiteral: "let jsObject = \(prefix)\(call)"),

Plugins/BridgeJS/Sources/BridgeJSMacros/JSMacroSupport.swift

@@ -202,11 +202,14 @@ enum JSMacroHelper {
         in context: some MacroExpansionContext,
         additionalNotes: [Note] = []
     ) {
-        let throwsTypeName = signature.effectSpecifiers?.throwsClause?.type?.as(IdentifierTypeSyntax.self)?.name.text
+        let throwsClause = signature.effectSpecifiers?.throwsClause
+        let throwsTypeName = throwsClause?.type?.as(IdentifierTypeSyntax.self)?.name.text
         let isJSException = throwsTypeName == "JSException"
+        let isAllowedGenericError = throwsClause != nil && (throwsTypeName == nil || throwsTypeName == "Error" || throwsTypeName == "Swift.Error")
         guard !isJSException else { return }
+        guard !isAllowedGenericError else { return }
 
-        let newThrowsClause = jsExceptionThrowsClause(from: signature.effectSpecifiers?.throwsClause)
+        let newThrowsClause = jsExceptionThrowsClause(from: throwsClause)
 
         let fixIt: FixIt
         if let throwsClause = signature.effectSpecifiers?.throwsClause {
@@ -215,11 +218,14 @@ enum JSMacroHelper {
                 changes: [.replace(oldNode: Syntax(throwsClause), newNode: Syntax(newThrowsClause))]
             )
         } else {
+            let adjustedParameterClause = signature.parameterClause.with(\.rightParen.trailingTrivia, .spaces(0))
             let newEffects = FunctionEffectSpecifiersSyntax(
                 asyncSpecifier: signature.effectSpecifiers?.asyncSpecifier,
                 throwsClause: newThrowsClause
             )
-            let newSignature = signature.with(\.effectSpecifiers, newEffects)
+            let newSignature = signature
+                .with(\.parameterClause, adjustedParameterClause)
+                .with(\.effectSpecifiers, newEffects)
             fixIt = FixIt(
                 message: JSMacroFixItMessage(message: "Declare throws(JSException)"),
                 changes: [.replace(oldNode: Syntax(signature), newNode: Syntax(newSignature))]
@@ -267,6 +273,7 @@ enum JSMacroHelper {
     static func jsExceptionThrowsClause(from throwsClause: ThrowsClauseSyntax?) -> ThrowsClauseSyntax {
         let throwsSpecifier = (throwsClause?.throwsSpecifier ?? .keyword(.throws, leadingTrivia: .space))
             .with(\.trailingTrivia, .spaces(0))
+            .with(\.leadingTrivia, throwsClause?.throwsSpecifier.leadingTrivia ?? .space)
         let leftParen = throwsClause?.leftParen ?? .leftParenToken()
         let rightParen = (throwsClause?.rightParen ?? .rightParenToken())
             .with(\.trailingTrivia, throwsClause?.rightParen?.trailingTrivia ?? .space)

Plugins/BridgeJS/Sources/BridgeJSMacros/JSSetterMacro.swift

@@ -189,14 +189,16 @@ extension JSSetterMacro: BodyMacro {
         arguments.append(paramName.text)
 
         // Ensure throws(JSException) is declared to match the generated body.
-        let existingThrowsType = functionDecl.signature.effectSpecifiers?.throwsClause?.type
+        let existingThrowsClause = functionDecl.signature.effectSpecifiers?.throwsClause
+        let existingThrowsType = existingThrowsClause?.type
             .flatMap { $0.as(IdentifierTypeSyntax.self)?.name.text }
         let hasTypedJSException = existingThrowsType == "JSException"
-        let hasAnyThrows = functionDecl.signature.effectSpecifiers?.throwsClause != nil
+        let isAllowedGenericError = existingThrowsClause != nil && (existingThrowsType == nil || existingThrowsType == "Error" || existingThrowsType == "Swift.Error")
+        let hasAnyThrows = existingThrowsClause != nil
 
-        if !hasTypedJSException {
+        if !hasTypedJSException && !isAllowedGenericError {
             let throwsClause = JSMacroHelper.jsExceptionThrowsClause(
-                from: functionDecl.signature.effectSpecifiers?.throwsClause
+                from: existingThrowsClause
             )
             let newEffects = (functionDecl.signature.effectSpecifiers
                 ?? FunctionEffectSpecifiersSyntax(asyncSpecifier: nil, throwsClause: nil))

Plugins/BridgeJS/Tests/BridgeJSMacrosTests/JSFunctionMacroTests.swift

@@ -102,11 +102,28 @@ import BridgeJSMacros
                     return try _$parse(json)
                 }
                 """,
+            macroSpecs: macroSpecs,
+            indentationWidth: indentationWidth,
+        )
+    }
+
+    @Test func topLevelFunctionThrowsWrongType() {
+        TestSupport.assertMacroExpansion(
+            """
+            @JSFunction
+            func parse(json: String) throws(CustomError) -> [String: Any]
+            """,
+            expandedSource: """
+                func parse(json: String) throws(CustomError) -> [String: Any] {
+                    return try _$parse(json)
+                }
+                """,
             diagnostics: [
                 DiagnosticSpec(
                     message: "@JSFunction throws must be declared as throws(JSException).",
                     line: 1,
                     column: 1,
+                    severity: .error,
                     notes: [
                         NoteSpec(
                             message: "@JSFunction must propagate JavaScript errors as JSException.",
@@ -129,23 +146,22 @@ import BridgeJSMacros
         )
     }
 
-    @Test func topLevelFunctionThrowsWrongType() {
+    @Test func topLevelFunctionMissingThrowsClause() {
         TestSupport.assertMacroExpansion(
             """
             @JSFunction
-            func parse(json: String) throws(CustomError) -> [String: Any]
+            func greet(name: String) -> String
             """,
             expandedSource: """
-                func parse(json: String) throws(CustomError) -> [String: Any] {
-                    return try _$parse(json)
+                func greet(name: String) -> String {
+                    return try _$greet(name)
                 }
                 """,
             diagnostics: [
                 DiagnosticSpec(
                     message: "@JSFunction throws must be declared as throws(JSException).",
                     line: 1,
                     column: 1,
-                    severity: .error,
                     notes: [
                         NoteSpec(
                             message: "@JSFunction must propagate JavaScript errors as JSException.",
@@ -162,7 +178,7 @@ import BridgeJSMacros
             applyFixIts: ["Declare throws(JSException)"],
             fixedSource: """
                 @JSFunction
-                func parse(json: String) throws(JSException) -> [String: Any]
+                func greet(name: String) throws(JSException) -> String
                 """,
             indentationWidth: indentationWidth,
         )

Plugins/BridgeJS/Tests/BridgeJSMacrosTests/JSSetterMacroTests.swift

@@ -309,10 +309,10 @@ import BridgeJSMacros
         TestSupport.assertMacroExpansion(
             """
             @JSSetter
-            func setFoo(_ value: Foo) throws(Error)
+            func setFoo(_ value: Foo) throws(CustomError)
             """,
             expandedSource: """
-                func setFoo(_ value: Foo) throws(Error) {
+                func setFoo(_ value: Foo) throws(CustomError) {
                     try _$foo_set(value)
                 }
                 """,
@@ -343,6 +343,22 @@ import BridgeJSMacros
         )
     }
 
+    @Test func setterThrowsErrorAccepted() {
+        TestSupport.assertMacroExpansion(
+            """
+            @JSSetter
+            func setFoo(_ value: Foo) throws(Error)
+            """,
+            expandedSource: """
+                func setFoo(_ value: Foo) throws(Error) {
+                    try _$foo_set(value)
+                }
+                """,
+            macroSpecs: macroSpecs,
+            indentationWidth: indentationWidth,
+        )
+    }
+
     @Test func unsupportedDeclaration() {
         TestSupport.assertMacroExpansion(
             """