[ReturnSelf] Allows Protocols to Return Self

Sources/MockoloFramework/Models/ClosureModel.swift

@@ -31,15 +31,15 @@ final class ClosureModel: Model {
     }
 
 
-    init(name: String, genericTypeParams: [ParamModel], paramNames: [String], paramTypes: [Type], suffix: String, returnType: Type) {
+    init(name: String, genericTypeParams: [ParamModel], paramNames: [String], paramTypes: [Type], suffix: String, returnType: Type, encloser: String) {
         self.name = name + .handlerSuffix
         self.suffix = suffix
         let genericTypeNameList = genericTypeParams.map(path: \.name)
         self.genericTypeNames = genericTypeNameList
         self.paramNames = paramNames
         self.paramTypes = paramTypes
         self.funcReturnType = returnType
-        self.type = Type.toClosureType(with: paramTypes, typeParams: genericTypeNameList, suffix: suffix, returnType: returnType)
+        self.type = Type.toClosureType(with: paramTypes, typeParams: genericTypeNameList, suffix: suffix, returnType: returnType, encloser: encloser)
     }
 
     func render(with identifier: String, encloser: String, useTemplateFunc: Bool = false, useMockObservable: Bool = false, enableFuncArgsHistory: Bool = false) -> String? {

Sources/MockoloFramework/Models/MethodModel.swift

@@ -102,7 +102,7 @@ final class MethodModel: Model {
         return ret
     }()
 
-    lazy var handler: ClosureModel? = {
+    func handler(encloser: String) -> ClosureModel? {
         if isInitializer {
             return nil
         }
@@ -114,10 +114,11 @@ final class MethodModel: Model {
                                paramNames: paramNames,
                                paramTypes: paramTypes,
                                suffix: suffix,
-                               returnType: type)
+                               returnType: type,
+                               encloser: encloser)
 
         return ret
-    }()
+    }
 
 
     init(name: String,
@@ -192,7 +193,7 @@ final class MethodModel: Model {
                                          accessLevel: accessLevel,
                                          suffix: suffix,
                                          argsHistory: argsHistory,
-                                         handler: handler)
+                                         handler: handler(encloser: encloser))
         return result
     }
 }

Sources/MockoloFramework/Parsers/ViaSwiftSyntax/SwiftSyntaxExtensions.swift

@@ -256,7 +256,7 @@ extension ProtocolDeclSyntax: EntityNode {
     var name: String {
         return identifier.text
     }
-    
+
     var accessLevel: String {
         return self.modifiers?.acl ?? ""
     }

Sources/MockoloFramework/Templates/MethodTemplate.swift

@@ -34,7 +34,7 @@ extension MethodModel {
         var template = ""
 
         let returnTypeName = returnType.isUnknown ? "" : returnType.typeName
-        
+
         let acl = accessLevel.isEmpty ? "" : accessLevel+" "
         let genericTypeDeclsStr = genericTypeParams.compactMap {$0.render(with: "", encloser: "")}.joined(separator: ", ")
         let genericTypesStr = genericTypeDeclsStr.isEmpty ? "" : "<\(genericTypeDeclsStr)>"
@@ -142,4 +142,3 @@ extension MethodModel {
         return template
     }
 }
-

Sources/MockoloFramework/Utils/StringExtensions.swift

@@ -41,6 +41,7 @@ extension String {
 
     static let `inout` = "inout"
     static let hasBlankInit = "_hasBlankInit"
+    static let `Self` = "Self"
     static let `static` = "static"
     static let importSpace = "import "
     static public let `class` = "class"

Sources/MockoloFramework/Utils/TypeParser.swift

@@ -129,6 +129,10 @@ public final class Type {
         return typeName.hasPrefix(String.escaping)
     }
 
+    var isSelf: Bool {
+        return typeName == String.`Self`
+    }
+
     var splitByClosure: Bool {
         let arg = typeName
         if let closureOpRange = arg.range(of: String.closureArrow) {
@@ -499,14 +503,16 @@ public final class Type {
     }
 
 
-    static func toClosureType(with params: [Type], typeParams: [String], suffix: String, returnType: Type) -> Type {
+    static func toClosureType(with params: [Type], typeParams: [String], suffix: String, returnType: Type, encloser: String) -> Type {
+
 
         let displayableParamTypes = params.map { (subtype: Type) -> String in
             return subtype.processTypeParams(with: typeParams)
         }
 
         let displayableParamStr = displayableParamTypes.joined(separator: ", ")
         var displayableReturnType = returnType.typeName
+
         let returnComps = displayableReturnType.literalComponents
 
         var returnAsStr = ""
@@ -521,6 +527,8 @@ public final class Type {
             } else if returnType.isIUO {
                 displayableReturnType = .any + "!"
                 returnAsStr.removeLast()
+            } else if returnType.isSelf {
+                returnAsStr = String.`Self`
             } else {
                 displayableReturnType = .any
             }
@@ -530,6 +538,11 @@ public final class Type {
             }
         }
 
+         if returnType.isSelf {
+            displayableReturnType = encloser
+            returnTypeCast = " as! " + String.`Self`
+        }
+
         let isSimpleTuple = displayableReturnType.hasPrefix("(") && displayableReturnType.hasSuffix(")") &&
             displayableReturnType.components(separatedBy: CharacterSet(charactersIn: "()")).filter({!$0.isEmpty}).count <= 1