Generate mock method with Typed Throw

Package.swift

@@ -11,7 +11,7 @@ let package = Package(
         .library(name: "MockoloFramework", targets: ["MockoloFramework"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-syntax.git", from: "510.0.1"),
+        .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "600.0.0-prerelease-2024-06-12"),
         .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.2.2"),
     ],
     targets: [

Sources/MockoloFramework/Parsers/SwiftSyntaxExtensions.swift

@@ -432,7 +432,7 @@ extension FunctionDeclSyntax {
                                     genericTypeParams: genericTypeParams,
                                     genericWhereClause: genericWhereClause,
                                     params: params,
-                                    throwsOrRethrows: self.signature.effectSpecifiers?.throwsSpecifier?.text,
+									throwsOrRethrows: self.signature.effectSpecifiers?.throwsClause?.text,
                                     asyncOrReasync: self.signature.effectSpecifiers?.asyncSpecifier?.text,
                                     isStatic: isStatic,
                                     offset: self.offset,
@@ -473,7 +473,7 @@ extension InitializerDeclSyntax {
                            genericTypeParams: genericTypeParams,
                            genericWhereClause: genericWhereClause,
                            params: params,
-                           throwsOrRethrows: self.signature.effectSpecifiers?.throwsSpecifier?.text,
+						   throwsOrRethrows: self.signature.effectSpecifiers?.throwsClause?.text,
                            asyncOrReasync: self.signature.effectSpecifiers?.asyncSpecifier?.text,
                            isStatic: false,
                            offset: self.offset,
@@ -570,6 +570,17 @@ extension TypeAliasDeclSyntax {
     }
 }
 
+extension ThrowsClauseSyntax {
+
+    var text: String {
+        if let type {
+            "\(throwsSpecifier.text)(\(type.description))"
+        } else {
+            throwsSpecifier.text
+        }
+    }
+}
+
 final class EntityVisitor: SyntaxVisitor {
     var entities: [Entity] = []
     var imports: [String: [String]] = [:]

Sources/MockoloFramework/Utils/StringExtensions.swift

@@ -108,10 +108,10 @@ extension String {
     ///
     """
 
-
     var hasThrowsOrRethrows: Bool {
         return components(separatedBy: .whitespaces).contains { component in
-            return component == .throws || component == .rethrows
+            let hasTypedThrow = hasPrefix(String.throws.withLeftParen) && hasSuffix(")")
+            return component == .throws || hasTypedThrow || component == .rethrows
         }
     }
 

Sources/MockoloFramework/Utils/TypeParser.swift

@@ -510,6 +510,25 @@ public final class `Type` {
         return mutableArg
     }
 
+    /// Parse throws clause from suffix and return typed-throw's type.
+    ///
+    /// - Returns: if typed-throw is used, returns its concrete type, unless returns nil.
+    static func extractTypedThrow(
+        suffix: String
+    ) -> String? {
+        return suffix
+            .components(separatedBy: .whitespaces)
+            .compactMap { clause in
+                guard let prefixRange = clause.range(of: "\(String.throws)(") else {
+                    return nil
+                }
+                let endIndex = clause.dropLast().endIndex
+                return String(
+                    clause[prefixRange.upperBound..<endIndex]
+                )
+            }
+            .first
+    }
 
     static func toClosureType(with params: [Type], typeParams: [String], suffix: String, returnType: Type, encloser: String) -> Type {
 
@@ -558,9 +577,18 @@ public final class `Type` {
             displayableReturnType = "(\(displayableReturnType))"
         }
 
+        let hasThrowsOrRethrows = suffix.hasThrowsOrRethrows
+        let typedThrowTypeName = extractTypedThrow(suffix: suffix)
+
+        let thrownSuffix: String = if let typedThrowTypeName {
+            "\(String.throws)(\(typedThrowTypeName))"
+        } else {
+            String.throws
+        }
+
         let suffixStr = [
             suffix.hasAsync ? String.async + " " : nil,
-            suffix.hasThrowsOrRethrows ? String.throws + " " : nil,
+            hasThrowsOrRethrows ? thrownSuffix + " " : nil,
         ].compactMap { $0 }.joined()
 
         let typeStr = "((\(displayableParamStr)) \(suffixStr)-> \(displayableReturnType))?"

Tests/TestFuncs/TestFuncThrow/FixtureFuncThrow.swift

@@ -1,23 +1,15 @@
 import MockoloFramework
 
 
-let funcThrow2 = """
-import Foundation
-
-/// \(String.mockAnnotation)
-protocol FuncThrow {
-func update<T>(arg1: T, arg2: () throws -> T) rethrows -> T
-func update<T, U>(arg1: T, arg2: @escaping (U) throws -> ()) throws -> ((T) -> (U))
-}
-"""
-
 let funcThrow = """
 import Foundation
 
 /// \(String.mockAnnotation)
 protocol FuncThrow {
     func f1(arg: Int) throws -> String
     func f2(arg: Int) throws
+    func f3(arg: Int) throws(SomeError)
+    func f4(arg: Int) throws(SomeError) -> String
     func g1(arg: (Int) throws -> ())
                 throws -> String
     func g2(arg: (Int) throws -> ()) throws
@@ -57,6 +49,26 @@ class FuncThrowMock: FuncThrow {
 
     }
 
+    private(set) var f3CallCount = 0
+    var f3Handler: ((Int) throws(SomeError) -> ())?
+    func f3(arg: Int) throws(SomeError)  {
+        f3CallCount += 1
+        if let f3Handler = f3Handler {
+            try f3Handler(arg)
+        }
+
+    }
+
+    private(set) var f4CallCount = 0
+    var f4Handler: ((Int) throws(SomeError) -> (String))?
+    func f4(arg: Int) throws(SomeError) -> String {
+        f4CallCount += 1
+        if let f4Handler = f4Handler {
+            return try f4Handler(arg)
+        }
+        return ""
+    }
+
     private(set) var g1CallCount = 0
     var g1Handler: (((Int) throws -> ()) throws -> (String))?
     func g1(arg: (Int) throws -> ()) throws -> String {

Tests/TestInit/FixtureInit.swift

@@ -326,3 +326,43 @@ class MyProtocolMock: MyProtocol {
 
 }
 """
+
+let throwableInit = """
+/// \(String.mockAnnotation)
+protocol MyProtocol {
+    init(param: String) throws
+}
+"""
+
+let throwableInitMock = """
+
+
+
+class MyProtocolMock: MyProtocol {
+    private var _param: String!
+    init() { }
+    required init(param: String = "") throws {
+        self._param = param
+    }
+}
+"""
+
+let typedThrowableInit = """
+/// \(String.mockAnnotation)
+protocol MyProtocol {
+	init(param: String) throws(SomeError)
+}
+"""
+
+let typedThrowableInitMock = """
+
+
+
+class MyProtocolMock: MyProtocol {
+	private var _param: String!
+	init() { }
+	required init(param: String = "") throws(SomeError) {
+		self._param = param
+	}
+}
+"""

Tests/TestInit/InitTests.swift

@@ -41,4 +41,18 @@ class InitTests: MockoloTestCase {
             dstContent: initWithSameParamNameButDifferentTypeMock
         )
     }
+
+    func testThrowableInit() {
+        verify(
+            srcContent: throwableInit,
+            dstContent: throwableInitMock
+        )
+    }
+
+    func testTypedThrowableInit() {
+        verify(
+            srcContent: typedThrowableInit,
+            dstContent: typedThrowableInitMock
+        )
+    }
 }