Correct the throws clause in the closure within template logic to support TypedThrow.

Package.resolved

@@ -12,7 +12,7 @@
     {
       "identity" : "swift-syntax",
       "kind" : "remoteSourceControl",
-      "location" : "https://github.com/apple/swift-syntax.git",
+      "location" : "https://github.com/swiftlang/swift-syntax.git",
       "state" : {
         "revision" : "0687f71944021d616d34d922343dcef086855920",
         "version" : "600.0.1"

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: "600.0.1"),
+        .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "600.0.1"),
         .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.5.0"),
     ],
     targets: [

Sources/MockoloFramework/Models/ArgumentsHistoryModel.swift

@@ -4,7 +4,7 @@ final class ArgumentsHistoryModel: Model {
     var name: String
     var type: SwiftType
     var offset: Int64 = .max
-    let suffix: String
+    let suffix: FunctionSuffixClause?
     let capturableParamNames: [String]
     let capturableParamTypes: [SwiftType]
     let isHistoryAnnotated: Bool
@@ -13,7 +13,7 @@ final class ArgumentsHistoryModel: Model {
         return .argumentsHistory
     }
 
-    init?(name: String, genericTypeParams: [ParamModel], params: [ParamModel], isHistoryAnnotated: Bool, suffix: String) {
+    init?(name: String, genericTypeParams: [ParamModel], params: [ParamModel], isHistoryAnnotated: Bool, suffix: FunctionSuffixClause?) {
         // Value contains closure is not supported.
         let capturables = params.filter { !$0.type.hasClosure && !$0.type.isEscaping && !$0.type.isAutoclosure }
         guard !capturables.isEmpty else {

Sources/MockoloFramework/Models/ClosureModel.swift

@@ -24,14 +24,14 @@ final class ClosureModel: Model {
     let genericTypeNames: [String]
     let paramNames: [String]
     let paramTypes: [SwiftType]
-    let suffix: String
+    let suffix: FunctionSuffixClause?
 
     var modelType: ModelType {
         return .closure
     }
 
 
-    init(name: String, genericTypeParams: [ParamModel], paramNames: [String], paramTypes: [SwiftType], suffix: String, returnType: SwiftType, encloser: String) {
+    init(name: String, genericTypeParams: [ParamModel], paramNames: [String], paramTypes: [SwiftType], suffix: FunctionSuffixClause?, returnType: SwiftType, encloser: String) {
         self.name = name + .handlerSuffix
         self.suffix = suffix
         let genericTypeNameList = genericTypeParams.map(\.name)

Sources/MockoloFramework/Models/MethodModel.swift

@@ -38,7 +38,7 @@ final class MethodModel: Model {
     var modelDescription: String? = nil
     var isStatic: Bool
     let shouldOverride: Bool
-    let suffix: String
+    let suffix: FunctionSuffixClause?
     let kind: MethodKind
     let funcsWithArgsHistory: [String]
     let customModifiers: [String : Modifier]
@@ -167,8 +167,8 @@ final class MethodModel: Model {
          genericTypeParams: [ParamModel],
          genericWhereClause: String?,
          params: [ParamModel],
-         throwsOrRethrows: String?,
-         asyncOrReasync: String?,
+         throwsOrRethrows: FunctionThrowsSuffix?,
+         asyncOrReasync: FunctionAsyncSuffix?,
          isStatic: Bool,
          offset: Int64,
          length: Int64,
@@ -178,7 +178,10 @@ final class MethodModel: Model {
          processed: Bool) {
         self.name = name.trimmingCharacters(in: .whitespaces)
         self.type = SwiftType(typeName.trimmingCharacters(in: .whitespaces))
-        self.suffix = [asyncOrReasync, throwsOrRethrows].compactMap { $0 }.joined(separator: " ")
+        self.suffix = FunctionSuffixClause(
+            throwsSuffix: throwsOrRethrows,
+            asyncSuffix: asyncOrReasync
+        )
         self.offset = offset
         self.length = length
         self.kind = kind
@@ -243,3 +246,38 @@ final class MethodModel: Model {
         return result
     }
 }
+
+/// throws, rethrows
+///
+/// if throws clause has a type information, the associated value `type` is not `nil`.
+struct FunctionThrowsSuffix {
+    let isRethrows: Bool
+    let type: String?
+}
+
+/// async, reasync
+struct FunctionAsyncSuffix {
+    var isReasync: Bool
+
+    var text: String {
+        isReasync ? String.reasync : String.async
+    }
+}
+
+/// Function Suffix Clause such as async / throws.
+///
+/// Since the support of typed throw, it is necessary to prepare a type that represents suffix in place of String type
+/// due to the swift syntax's complexity.
+struct FunctionSuffixClause {
+    var throwsSuffix: FunctionThrowsSuffix?
+    var asyncSuffix: FunctionAsyncSuffix?
+
+
+    init?(throwsSuffix: FunctionThrowsSuffix? = nil, asyncSuffix: FunctionAsyncSuffix? = nil) {
+        if throwsSuffix == nil, asyncSuffix == nil {
+            return nil
+        }
+        self.throwsSuffix = throwsSuffix
+        self.asyncSuffix = asyncSuffix
+    }
+}

Sources/MockoloFramework/Parsers/SwiftSyntaxExtensions.swift

@@ -423,24 +423,33 @@ extension FunctionDeclSyntax {
         let params = self.signature.parameterClause.parameters.compactMap { $0.model(inInit: false, declType: declType) }
         let genericTypeParams = self.genericParameterClause?.parameters.compactMap { $0.model(inInit: false) } ?? []
         let genericWhereClause = self.genericWhereClause?.description
-
-        let funcmodel = MethodModel(name: self.name.description,
-                                    typeName: self.signature.returnClause?.type.description ?? "",
-                                    kind: .funcKind,
-                                    encloserType: declType,
-                                    acl: acl,
-                                    genericTypeParams: genericTypeParams,
-                                    genericWhereClause: genericWhereClause,
-                                    params: params,
-                                    throwsOrRethrows: self.signature.effectSpecifiers?.throwsClause?.throwsSpecifier.text,
-                                    asyncOrReasync: self.signature.effectSpecifiers?.asyncSpecifier?.text,
-                                    isStatic: isStatic,
-                                    offset: self.offset,
-                                    length: self.length,
-                                    funcsWithArgsHistory: funcsWithArgsHistory ?? [],
-                                    customModifiers: customModifiers ?? [:],
-                                    modelDescription: self.description,
-                                    processed: processed)
+        let asyncSpecifier = self.signature.effectSpecifiers?.asyncSpecifier
+        let throwsClause = self.signature.effectSpecifiers?.throwsClause
+
+        let funcmodel = MethodModel(
+            name: self.name.description,
+            typeName: self.signature.returnClause?.type.description ?? "",
+            kind: .funcKind,
+            encloserType: declType,
+            acl: acl,
+            genericTypeParams: genericTypeParams,
+            genericWhereClause: genericWhereClause,
+            params: params,
+            throwsOrRethrows: throwsClause != nil ? FunctionThrowsSuffix(
+                    isRethrows: throwsClause!.throwsSpecifier.text == String.rethrows,
+                    type: throwsClause!.type?.description
+                ) : nil,
+            asyncOrReasync: asyncSpecifier != nil ? FunctionAsyncSuffix(
+                isReasync: asyncSpecifier!.text == String.rethrows
+            ) : nil,
+            isStatic: isStatic,
+            offset: self.offset,
+            length: self.length,
+            funcsWithArgsHistory: funcsWithArgsHistory ?? [],
+            customModifiers: customModifiers ?? [:],
+            modelDescription: self.description,
+            processed: processed
+        )
         return funcmodel
     }
 }
@@ -464,6 +473,8 @@ extension InitializerDeclSyntax {
         let params = self.signature.parameterClause.parameters.compactMap { $0.model(inInit: true, declType: declType) }
         let genericTypeParams = self.genericParameterClause?.parameters.compactMap { $0.model(inInit: true) } ?? []
         let genericWhereClause = self.genericWhereClause?.description
+        let asyncSpecifier = self.signature.effectSpecifiers?.asyncSpecifier
+        let throwsClause = self.signature.effectSpecifiers?.throwsClause
 
         return MethodModel(name: "init",
                            typeName: "",
@@ -473,8 +484,14 @@ extension InitializerDeclSyntax {
                            genericTypeParams: genericTypeParams,
                            genericWhereClause: genericWhereClause,
                            params: params,
-                           throwsOrRethrows: self.signature.effectSpecifiers?.throwsClause?.throwsSpecifier.text,
-                           asyncOrReasync: self.signature.effectSpecifiers?.asyncSpecifier?.text,
+                           throwsOrRethrows: throwsClause != nil ?
+                           FunctionThrowsSuffix(
+                                   isRethrows: throwsClause!.throwsSpecifier.text == String.rethrows,
+                                   type: throwsClause!.type?.description
+                               ) : nil,
+                           asyncOrReasync: asyncSpecifier != nil ? FunctionAsyncSuffix(
+                            isReasync: asyncSpecifier!.text == String.rethrows
+                           ) : nil,
                            isStatic: false,
                            offset: self.offset,
                            length: self.length,

Sources/MockoloFramework/Templates/ClosureTemplate.swift

@@ -22,7 +22,7 @@ extension ClosureModel {
                               genericTypeNames: [String],
                               paramVals: [String]?,
                               paramTypes: [SwiftType]?,
-                              suffix: String,
+                              suffix: FunctionSuffixClause?,
                               returnDefaultType: SwiftType) -> String {
 
         var handlerParamValsStr = ""
@@ -46,8 +46,8 @@ extension ClosureModel {
         let handlerReturnDefault = renderReturnDefaultStatement(name: name, type: returnDefaultType)
 
         let prefix = [
-            suffix.hasThrowsOrRethrows ? String.try + " " : nil,
-            suffix.hasAsync ? String.await + " " : nil,
+            suffix?.throwsSuffix != nil ? String.try + " " : nil,
+            suffix?.asyncSuffix != nil ? String.await + " " : nil,
         ].compactMap { $0 }.joined()
 
         let returnStr = returnDefaultType.typeName.isEmpty ? "" : "return "

Sources/MockoloFramework/Templates/FunctionSuffixTemplate.swift

@@ -0,0 +1,40 @@
+//
+//  Copyright (c) 2018. Uber Technologies
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+
+extension FunctionSuffixClause {
+    func applyFunctionSuffixTemplate(
+        forClosureTemplate: Bool
+    ) -> String {
+        var ret: String = ""
+        if let asyncSuffix {
+            ret += asyncSuffix.isReasync ? String.reasync : String.async
+        }
+        if let throwsSuffix {
+            if asyncSuffix != nil {
+                ret += " "
+            }
+            if !forClosureTemplate, throwsSuffix.isRethrows {
+                ret += String.rethrows
+            } else {
+                ret += String.throws
+                if let throwType = throwsSuffix.type {
+                    ret += "(\(throwType))"
+                }
+            }
+        }
+        return ret
+    }
+}

Sources/MockoloFramework/Templates/MethodTemplate.swift

@@ -31,7 +31,7 @@ extension MethodModel {
                              params: [ParamModel],
                              returnType: SwiftType,
                              accessLevel: String,
-                             suffix: String,
+                             suffix: FunctionSuffixClause?,
                              argsHistory: ArgumentsHistoryModel?,
                              handler: ClosureModel?) -> String {
         var template = ""
@@ -59,14 +59,14 @@ extension MethodModel {
             let handlerVarType = handler.type.typeName // ?? "Any"
             let handlerReturn = handler.render(with: identifier, encloser: "") ?? ""
 
-            let suffixStr = suffix.isEmpty ? "" : "\(suffix) "
+            let suffixStr = suffix == nil ? "" : "\(suffix!.applyFunctionSuffixTemplate(forClosureTemplate: false)) "
             let returnStr = returnTypeName.isEmpty ? "" : "-> \(returnTypeName)"
             let staticStr = isStatic ? String.static + " " : ""
             let keyword = isSubscript ? "" : "func "
             var body = ""
 
             if useTemplateFunc {
-                let callMockFunc = !suffix.hasThrowsOrRethrows && (handler.type.cast?.isEmpty ?? false)
+                let callMockFunc = suffix?.throwsSuffix == nil && (handler.type.cast?.isEmpty ?? false)
                 if callMockFunc {
                     let handlerParamValsStr = params.map { (arg) -> String in
                         if arg.type.typeName.hasPrefix(String.autoclosure) {

Sources/MockoloFramework/Templates/NominalTemplate.swift

@@ -195,7 +195,7 @@ extension NominalModel {
                 let genericTypeDeclsStr = m.genericTypeParams.compactMap {$0.render(with: "", encloser: "")}.joined(separator: ", ")
                 let genericTypesStr = genericTypeDeclsStr.isEmpty ? "" : "<\(genericTypeDeclsStr)>"
                 let paramDeclsStr = m.params.compactMap{$0.render(with: "", encloser: "")}.joined(separator: ", ")
-                let suffixStr = m.suffix.isEmpty ? "" : "\(m.suffix) "
+                let suffixStr = m.suffix == nil ? "" : "\(m.suffix!.applyFunctionSuffixTemplate(forClosureTemplate: false)) "
 
                 if override {
                     let paramsList = m.params.map { param in

Sources/MockoloFramework/Utils/StringExtensions.swift

@@ -32,6 +32,7 @@ extension String {
     static let `throws` = "throws"
     static let `rethrows` = "rethrows"
     static let async = "async"
+    static let reasync = "reasync"
     static let await = "await"
     static let `inout` = "inout"
     static let hasBlankInit = "_hasBlankInit"
@@ -110,19 +111,6 @@ extension String {
     ///
     """
 
-
-    var hasThrowsOrRethrows: Bool {
-        return components(separatedBy: .whitespaces).contains { component in
-            return component == .throws || component == .rethrows
-        }
-    }
-
-    var hasAsync: Bool {
-        return components(separatedBy: .whitespaces).contains { component in
-            return component == .async
-        }
-    }
-
     var safeName: String {
         var text = self
         if let keyword = text.withSyntaxText(Keyword.init),

Sources/MockoloFramework/Utils/TypeParser.swift

@@ -511,8 +511,7 @@ public final class SwiftType {
         return mutableArg
     }
 
-
-    static func toClosureType(with params: [SwiftType], typeParams: [String], suffix: String, returnType: SwiftType, encloser: String) -> SwiftType {
+    static func toClosureType(with params: [SwiftType], typeParams: [String], suffix: FunctionSuffixClause?, returnType: SwiftType, encloser: String) -> SwiftType {
 
 
         let displayableParamTypes = params.map { (subtype: SwiftType) -> String in
@@ -559,10 +558,7 @@ public final class SwiftType {
             displayableReturnType = "(\(displayableReturnType))"
         }
 
-        let suffixStr = [
-            suffix.hasAsync ? String.async + " " : nil,
-            suffix.hasThrowsOrRethrows ? String.throws + " " : nil,
-        ].compactMap { $0 }.joined()
+        let suffixStr = suffix != nil ? "\(suffix!.applyFunctionSuffixTemplate(forClosureTemplate: true)) " : ""
 
         let typeStr = "((\(displayableParamStr)) \(suffixStr)-> \(displayableReturnType))?"
         return SwiftType(typeStr, cast: returnTypeCast)