Avoid to generate duplicated variable name

Sources/MockoloFramework/Models/ClassModel.swift

@@ -25,7 +25,7 @@ final class ClassModel: Model {
     let identifier: String
     let declType: DeclType
     let entities: [(String, Model)]
-    let initParamCandidates: [Model]
+    let initParamCandidates: [VariableModel]
     let declaredInits: [MethodModel]
     let metadata: AnnotationMetadata?
 
@@ -39,7 +39,7 @@ final class ClassModel: Model {
          attributes: [String],
          offset: Int64,
          metadata: AnnotationMetadata?,
-         initParamCandidates: [Model],
+         initParamCandidates: [VariableModel],
          declaredInits: [MethodModel],
          entities: [(String, Model)]) {
         self.identifier = identifier 
@@ -55,7 +55,32 @@ final class ClassModel: Model {
         self.accessLevel = acl
     }
 
-    func render(with identifier: String, encloser: String, useTemplateFunc: Bool, useMockObservable: Bool, allowSetCallCount: Bool = false, mockFinal: Bool = false, enableFuncArgsHistory: Bool = false, disableCombineDefaultValues: Bool = false) -> String? {
-        return applyClassTemplate(name: name, identifier: self.identifier, accessLevel: accessLevel, attribute: attribute, declType: declType, metadata: metadata, useTemplateFunc: useTemplateFunc, useMockObservable: useMockObservable, allowSetCallCount: allowSetCallCount, mockFinal: mockFinal, enableFuncArgsHistory: enableFuncArgsHistory, disableCombineDefaultValues: disableCombineDefaultValues, initParamCandidates: initParamCandidates, declaredInits: declaredInits, entities: entities)
+    func render(
+        with identifier: String,
+        encloser: String,
+        useTemplateFunc: Bool,
+        useMockObservable: Bool,
+        allowSetCallCount: Bool = false,
+        mockFinal: Bool = false,
+        enableFuncArgsHistory: Bool = false,
+        disableCombineDefaultValues: Bool = false
+    ) -> String? {
+        return applyClassTemplate(
+            name: name,
+            identifier: self.identifier,
+            accessLevel: accessLevel,
+            attribute: attribute,
+            declType: declType,
+            metadata: metadata,
+            useTemplateFunc: useTemplateFunc,
+            useMockObservable: useMockObservable,
+            allowSetCallCount: allowSetCallCount,
+            mockFinal: mockFinal,
+            enableFuncArgsHistory: enableFuncArgsHistory,
+            disableCombineDefaultValues: disableCombineDefaultValues,
+            initParamCandidates: initParamCandidates,
+            declaredInits: declaredInits,
+            entities: entities
+        )
     }
 }

Sources/MockoloFramework/Models/ParamModel.swift

@@ -53,10 +53,37 @@ final class ParamModel: Model {
     var underlyingName: String {
         return "_\(name)"
     }
-
-    var asVarDecl: String? {
+
+    /// - Parameters:
+    ///     - eraseType:
+    ///         If other initializers in decl has same name as this param and type is different from each other,
+    ///         please pass `True` to this parameter. Default value is `false`.
+    ///
+    /// ```
+    ///     protocol A {
+    ///         init(param: String)
+    ///         init(param: any Sequence<Character>)
+    ///     }
+    ///     class B: A {
+    ///         var param: Any! // NOTE: type erasing
+    ///         init () {}
+    ///         required init(param: String) {
+    ///           self.param = param
+    ///         }
+    ///         required init(param: any Sequence<Character>) {
+    ///             self.param = param
+    ///         }
+    ///     }
+    /// ```
+    func asInitVarDecl(eraseType: Bool) -> String? {
         if self.inInit, self.needVarDecl {
-            return applyVarTemplate(name: name, type: type)
+            let type: `Type`
+            if eraseType {
+                type = Type(.any)
+            } else {
+                type = self.type
+            }
+            return applyVarTemplate(type: type)
         }
         return nil
     }

Sources/MockoloFramework/Models/ParsedEntity.swift

@@ -35,15 +35,17 @@ struct ResolvedEntity {
         return declaredInits.map { $0.params }.flatMap{$0}
     }
 
-    var initParamCandidates: [Model] {
-        return sortedInitVars(in: uniqueModels.map{$0.1})
+    var initParamCandidates: [VariableModel] {
+        return sortedInitVars(
+            in: uniqueModels.compactMap{ $0.1 as? VariableModel }
+        )
     }
 
     /// Returns models that can be used as parameters to an initializer
     /// @param models The models of the current entity including unprocessed (ones to generate) and
     ///             processed (already mocked by a previous run if any) models.
     /// @returns A list of init parameter models
-    private func sortedInitVars(`in` models: [Model]) -> [Model] {
+    private func sortedInitVars(`in` models: [VariableModel]) -> [VariableModel] {
         let processed = models.filter {$0.processed && $0.canBeInitParam}
         let unprocessed = models.filter {!$0.processed && $0.canBeInitParam}
 

Sources/MockoloFramework/Templates/ClassTemplate.swift

@@ -29,7 +29,7 @@ extension ClassModel {
                             mockFinal: Bool,
                             enableFuncArgsHistory: Bool,
                             disableCombineDefaultValues: Bool,
-                            initParamCandidates: [Model],
+                            initParamCandidates: [VariableModel],
                             declaredInits: [MethodModel],
                             entities: [(String, Model)]) -> String {
 
@@ -101,14 +101,16 @@ extension ClassModel {
         return template
     }
 
-    private func extraInitsIfNeeded(initParamCandidates: [Model],
-                                    declaredInits: [MethodModel],
-                                    acl: String,
-                                    declType: DeclType,
-                                    overrides: [String: String]?) -> String {
+    private func extraInitsIfNeeded(
+        initParamCandidates: [VariableModel],
+        declaredInits: [MethodModel],
+        acl: String,
+        declType: DeclType,
+        overrides: [String: String]?
+    ) -> String {
 
         let declaredInitParamsPerInit = declaredInits.map { $0.params }
-        
+
         var needParamedInit = false
         var needBlankInit = false
 
@@ -169,13 +171,23 @@ extension ClassModel {
         }
 
         let extraInitParamNames = initParamCandidates.map{$0.name}
-        let extraVarsToDecl = declaredInitParamsPerInit.flatMap{$0}.compactMap { (p: ParamModel) -> String? in
-            if !extraInitParamNames.contains(p.name) {
-                return p.asVarDecl
+        var processed = Set<String>()
+        let extraVarsToDecl = declaredInitParamsPerInit
+            .flatMap { $0 }
+            .compactMap { (p: ParamModel) -> String? in
+                if !extraInitParamNames.contains(p.name), !processed.contains(p.name) {
+                    processed.insert(p.name)
+                    let shouldEraseType = declaredInitParamsPerInit
+                        .flatMap { $0 }
+                        .checkHasConflictedParam(
+                            name: p.name,
+                            typeName: p.type.typeName
+                        )
+                    return p.asInitVarDecl(eraseType: shouldEraseType)
+                }
+                return nil
             }
-            return nil
-        }
-        .joined(separator: "\n")
+            .joined(separator: "\n")
 
         let declaredInitStr = declaredInits.compactMap { (m: MethodModel) -> String? in
             if case let .initKind(required, override) = m.kind, !m.processed {
@@ -293,3 +305,19 @@ extension ClassModel {
         }
     }
 }
+
+fileprivate extension Array where Element == ParamModel {
+    func findParams(name: String) -> [ParamModel] {
+        filter {
+            $0.name == name
+        }
+    }
+
+    /// Check if there is same parameter name with different typeName.
+    func checkHasConflictedParam(name: String, typeName: String) -> Bool {
+        let sameParams = findParams(
+            name: name
+        )
+        return !sameParams.allSatisfy { $0.type.typeName == typeName }
+    }
+}

Sources/MockoloFramework/Templates/ParamTemplate.swift

@@ -34,9 +34,8 @@ extension ParamModel {
         }
         return result
     }
-
-    func applyVarTemplate(name: String,
-                          type: Type) -> String {
+
+    func applyVarTemplate(type: `Type`) -> String {
         assert(!type.isUnknown)
         let vardecl = "\(1.tab)private var \(underlyingName): \(type.underlyingType)"
         return vardecl

Sources/MockoloFramework/Utils/TypeParser.swift

@@ -22,7 +22,7 @@ fileprivate var validIdentifierChars: CharacterSet = {
     return valid
 }()
 
-public final class Type {
+public final class `Type` {
     let typeName: String
     let cast: String?
     var cachedDefaultVal: String?

Tests/TestInit/FixtureInit.swift

@@ -268,3 +268,61 @@ public class ForcastUpdatingMock: ForcastUpdating {
 }
 """
 
+let initWithSameParamNameButDifferentType = """
+/// \(String.mockAnnotation)
+protocol MyProtocol {
+    init(param: Any)
+    init(param: String)
+    init(param: [Character])
+}
+"""
+
+let initWithSameParamNameButDifferentTypeMock = """
+
+
+
+class MyProtocolMock: MyProtocol {
+        private var _param: Any!
+    init() { }
+    required init(param: Any) {
+        self._param = param
+    }
+    required init(param: String = "") {
+        self._param = param
+    }
+    required init(param: [Character] = [Character]()) {
+        self._param = param
+    }
+
+
+}
+"""
+
+let multipleInitsWithSameParamName = """
+/// \(String.mockAnnotation)
+protocol MyProtocol {
+    init(param: String, anotherParam: Int)
+    init(param: String, anotherParam: String)
+}
+"""
+
+let multipleInitsWithSameParamNameMock = """
+
+
+
+class MyProtocolMock: MyProtocol {
+        private var _param: String!
+    private var _anotherParam: Any!
+    init() { }
+    required init(param: String = "", anotherParam: Int = 0) {
+        self._param = param
+        self._anotherParam = anotherParam
+    }
+    required init(param: String = "", anotherParam: String = "") {
+        self._param = param
+        self._anotherParam = anotherParam
+    }
+
+
+}
+"""

Tests/TestInit/InitTests.swift

@@ -27,4 +27,18 @@ class InitTests: MockoloTestCase {
         verify(srcContent: keywordParams,
                dstContent: keywordParamsMock)
     }
+
+    func testInitiWithSameParamName() {
+        verify(
+            srcContent: multipleInitsWithSameParamName,
+            dstContent: multipleInitsWithSameParamNameMock
+        )
+    }
+
+    func testInitiWithSameParamNameButDifferentType() {
+        verify(
+            srcContent: initWithSameParamNameButDifferentType,
+            dstContent: initWithSameParamNameButDifferentTypeMock
+        )
+    }
 }