Fix nested bracket type overloading

Sources/MockoloFramework/Utils/StringExtensions.swift

@@ -224,14 +224,7 @@ extension String {
     }
 }
 
-let separatorsForDisplay = CharacterSet(charactersIn: "<>[] :,()_-.&@#!{}@+\"\'")
-let separatorsForLiterals = CharacterSet(charactersIn: "?<>[] :,()_-.&@#!{}@+\"\'")
-
 extension StringProtocol {
-    var isNotEmpty: Bool {
-        return !isEmpty
-    }
-
     var capitalizeFirstLetter: String {
         return prefix(1).capitalized + dropFirst()
     }
@@ -252,19 +245,6 @@ extension StringProtocol {
         return false
     }
 
-    var literalComponents: [String] {
-        return self.components(separatedBy: separatorsForLiterals)
-    }
-
-    var displayableComponents: [String] {
-        let ret = self.replacingOccurrences(of: "?", with: "Optional")
-        return ret.components(separatedBy: separatorsForDisplay).filter {!$0.isEmpty}
-    }
-
-    var components: [String] {
-        return self.components(separatedBy: separatorsForDisplay).filter {!$0.isEmpty}
-    }
-
     var asTestableImport: String {
         return "@testable \(self.asImport)"
     }

Sources/MockoloFramework/Utils/SwiftType.swift

@@ -137,7 +137,36 @@ struct SwiftType: Equatable, CustomStringConvertible {
 
     /// variable safe name
     var displayName: String {
-        return typeName.displayableComponents.map(\.capitalizeFirstLetter).joined()
+        switch kind {
+        case .tuple(let tuple):
+            return tuple.elements.map { element in
+                if let label = element.label {
+                    return label.capitalizeFirstLetter + element.type.displayName
+                }
+                return element.type.displayName
+            }.joined()
+        case .nominal(let nominal):
+            let name: String
+            switch nominal.name {
+            case .arrayTypeSugarName: 
+                name = "Array"
+            case .dictionaryTypeSugarName:
+                name = "Dictionary"
+            case .optionalTypeSugarName:
+                name = "Optional"
+            default:
+                name = nominal.name.capitalizeFirstLetter
+            }
+            var result = nominal.namespace.map(\.displayName) ?? ""
+            result += name
+            result += nominal.genericParameterTypes.map(\.displayName).joined()
+            return result
+        case .closure(let closure):
+            return closure.arguments.map(\.type.displayName).joined()
+                + closure.returning.displayName
+        case .composition(let composition):
+            return composition.elements.map(\.displayName).joined()
+        }
     }
 
     func includingIdentifiers() -> [String] {

Tests/TestOverloads/FixtureDuplicates6.swift

@@ -0,0 +1,34 @@
+@Fixture enum overloadReturningBracketType {
+    /// @mockable
+    protocol P {
+        func foo() -> [String]
+        func foo() -> [[String]]
+    }
+
+    @Fixture enum expected {
+        class PMock: P {
+            init() { }
+
+
+            private(set) var fooCallCount = 0
+            var fooHandler: (() -> [String])?
+            func foo() -> [String] {
+                fooCallCount += 1
+                if let fooHandler = fooHandler {
+                    return fooHandler()
+                }
+                return [String]()
+            }
+
+            private(set) var fooArrayArrayStringCallCount = 0
+            var fooArrayArrayStringHandler: (() -> [[String]])?
+            func foo() -> [[String]] {
+                fooArrayArrayStringCallCount += 1
+                if let fooArrayArrayStringHandler = fooArrayArrayStringHandler {
+                    return fooArrayArrayStringHandler()
+                }
+                return [[String]]()
+            }
+        }
+    }
+}

Tests/TestOverloads/OverloadTests.swift

@@ -81,5 +81,11 @@ class OverloadTests: MockoloTestCase {
             dstContent: compositionInheritanceMock
         )
     }
-
+
+    func testOverloadReturningBracketType() {
+        verify(
+            srcContent: overloadReturningBracketType._source,
+            dstContent: overloadReturningBracketType.expected._source
+        )
+    }
 }

Tests/TestTuplesBrackets/FixtureTuplesBrackets.swift

@@ -68,44 +68,34 @@ class NonSimpleTypesMock: NonSimpleTypes {
         return Observable<(ItemType, ())>.empty()
     }
 
-    private(set) var updateObservableItemTypeOptionalCallCount = 0
-    var updateObservableItemTypeOptionalHandler: (() -> Observable<(ItemType, ())>?)?
+    private(set) var updateOptionalObservableItemTypeCallCount = 0
+    var updateOptionalObservableItemTypeHandler: (() -> Observable<(ItemType, ())>?)?
     func update() -> Observable<(ItemType, ())>? {
-        updateObservableItemTypeOptionalCallCount += 1
-        if let updateObservableItemTypeOptionalHandler = updateObservableItemTypeOptionalHandler {
-            return updateObservableItemTypeOptionalHandler()
+        updateOptionalObservableItemTypeCallCount += 1
+        if let updateOptionalObservableItemTypeHandler = updateOptionalObservableItemTypeHandler {
+            return updateOptionalObservableItemTypeHandler()
         }
         return nil
     }
 
-    private(set) var updateObservableSomeKeySomeTypeCallCount = 0
-    var updateObservableSomeKeySomeTypeHandler: (() -> Observable<[SomeKey: SomeType]>)?
+    private(set) var updateObservableDictionarySomeKeySomeTCallCount = 0
+    var updateObservableDictionarySomeKeySomeTHandler: (() -> Observable<[SomeKey: SomeType]>)?
     func update() -> Observable<[SomeKey: SomeType]> {
-        updateObservableSomeKeySomeTypeCallCount += 1
-        if let updateObservableSomeKeySomeTypeHandler = updateObservableSomeKeySomeTypeHandler {
-            return updateObservableSomeKeySomeTypeHandler()
+        updateObservableDictionarySomeKeySomeTCallCount += 1
+        if let updateObservableDictionarySomeKeySomeTHandler = updateObservableDictionarySomeKeySomeTHandler {
+            return updateObservableDictionarySomeKeySomeTHandler()
         }
         return Observable<[SomeKey: SomeType]>.empty()
     }
 
-    private(set) var updateStringIntCallCount = 0
-    var updateStringIntHandler: (() -> [String: Int])?
-    func update() -> [String: Int] {
-        updateStringIntCallCount += 1
-        if let updateStringIntHandler = updateStringIntHandler {
-            return updateStringIntHandler()
-        }
-        return [String: Int]()
-    }
-
     private(set) var updateDictionaryStringIntCallCount = 0
-    var updateDictionaryStringIntHandler: (() -> Dictionary<String, Int>)?
-    func update() -> Dictionary<String, Int> {
+    var updateDictionaryStringIntHandler: (() -> [String: Int])?
+    func update() -> [String: Int] {
         updateDictionaryStringIntCallCount += 1
         if let updateDictionaryStringIntHandler = updateDictionaryStringIntHandler {
             return updateDictionaryStringIntHandler()
         }
-        return Dictionary<String, Int>()
+        return [String: Int]()
     }
 
     private(set) var updateObservableDoubleFloatCallCount = 0
@@ -118,64 +108,64 @@ class NonSimpleTypesMock: NonSimpleTypes {
         return Observable<Double, Float>.empty()
     }
 
-    private(set) var updateStringCallCount = 0
-    var updateStringHandler: (() -> [String])?
+    private(set) var updateArrayStringCallCount = 0
+    var updateArrayStringHandler: (() -> [String])?
     func update() -> [String] {
-        updateStringCallCount += 1
-        if let updateStringHandler = updateStringHandler {
-            return updateStringHandler()
+        updateArrayStringCallCount += 1
+        if let updateArrayStringHandler = updateArrayStringHandler {
+            return updateArrayStringHandler()
         }
         return [String]()
     }
 
-    private(set) var updateStringArrayIntCallCount = 0
-    var updateStringArrayIntHandler: (() -> [String: Array<Int>])?
+    private(set) var updateArrayArrayStringCallCount = 0
+    var updateArrayArrayStringHandler: (() -> [[String]])?
+    func update() -> [[String]] {
+        updateArrayArrayStringCallCount += 1
+        if let updateArrayArrayStringHandler = updateArrayArrayStringHandler {
+            return updateArrayArrayStringHandler()
+        }
+        return [[String]]()
+    }
+
+    private(set) var updateDictionaryStringArrayIntCallCount = 0
+    var updateDictionaryStringArrayIntHandler: (() -> [String: Array<Int>])?
     func update() -> [String: Array<Int>] {
-        updateStringArrayIntCallCount += 1
-        if let updateStringArrayIntHandler = updateStringArrayIntHandler {
-            return updateStringArrayIntHandler()
+        updateDictionaryStringArrayIntCallCount += 1
+        if let updateDictionaryStringArrayIntHandler = updateDictionaryStringArrayIntHandler {
+            return updateDictionaryStringArrayIntHandler()
         }
         return [String: Array<Int>]()
     }
 
-    private(set) var updateStringDictionaryIntDoubleCallCount = 0
-    var updateStringDictionaryIntDoubleHandler: (() -> [String: Dictionary<Int, Double>])?
+    private(set) var updateDictionaryStringDictionaryIntDouCallCount = 0
+    var updateDictionaryStringDictionaryIntDouHandler: (() -> [String: Dictionary<Int, Double>])?
     func update() -> [String: Dictionary<Int, Double>] {
-        updateStringDictionaryIntDoubleCallCount += 1
-        if let updateStringDictionaryIntDoubleHandler = updateStringDictionaryIntDoubleHandler {
-            return updateStringDictionaryIntDoubleHandler()
+        updateDictionaryStringDictionaryIntDouCallCount += 1
+        if let updateDictionaryStringDictionaryIntDouHandler = updateDictionaryStringDictionaryIntDouHandler {
+            return updateDictionaryStringDictionaryIntDouHandler()
         }
         return [String: Dictionary<Int, Double>]()
     }
 
-    private(set) var updateStringIntArrayStringCallCount = 0
-    var updateStringIntArrayStringHandler: (() -> ([[String]], [Int], Array<[String]>))?
+    private(set) var updateArrayArrayStringArrayIntArrayArrCallCount = 0
+    var updateArrayArrayStringArrayIntArrayArrHandler: (() -> ([[String]], [Int], Array<[String]>))?
     func update() -> ([[String]], [Int], Array<[String]>) {
-        updateStringIntArrayStringCallCount += 1
-        if let updateStringIntArrayStringHandler = updateStringIntArrayStringHandler {
-            return updateStringIntArrayStringHandler()
+        updateArrayArrayStringArrayIntArrayArrCallCount += 1
+        if let updateArrayArrayStringArrayIntArrayArrHandler = updateArrayArrayStringArrayIntArrayArrHandler {
+            return updateArrayArrayStringArrayIntArrayArrHandler()
         }
         return ([[String]](), [Int](), Array<[String]>())
     }
 
-    private(set) var updateArrayStringIntCallCount = 0
-    var updateArrayStringIntHandler: (() -> Array<[String: Int]>)?
-    func update() -> Array<[String: Int]> {
-        updateArrayStringIntCallCount += 1
-        if let updateArrayStringIntHandler = updateArrayStringIntHandler {
-            return updateArrayStringIntHandler()
-        }
-        return Array<[String: Int]>()
-    }
-
     private(set) var updateArrayDictionaryStringIntCallCount = 0
-    var updateArrayDictionaryStringIntHandler: (() -> Array<Dictionary<String, Int>>)?
-    func update() -> Array<Dictionary<String, Int>> {
+    var updateArrayDictionaryStringIntHandler: (() -> Array<[String: Int]>)?
+    func update() -> Array<[String: Int]> {
         updateArrayDictionaryStringIntCallCount += 1
         if let updateArrayDictionaryStringIntHandler = updateArrayDictionaryStringIntHandler {
             return updateArrayDictionaryStringIntHandler()
         }
-        return Array<Dictionary<String, Int>>()
+        return Array<[String: Int]>()
     }
 
     private(set) var updateArrayStringArrayIntCallCount = 0
@@ -188,22 +178,12 @@ class NonSimpleTypesMock: NonSimpleTypes {
         return (Array<String>(), Array<Int>())
     }
 
-    private(set) var updateArrayStringCallCount = 0
-    var updateArrayStringHandler: (() -> Array<String>)?
-    func update() -> Array<String> {
-        updateArrayStringCallCount += 1
-        if let updateArrayStringHandler = updateArrayStringHandler {
-            return updateArrayStringHandler()
-        }
-        return Array<String>()
-    }
-
-    private(set) var updateResultDoubleOptionalStatusBoolCallCount = 0
-    var updateResultDoubleOptionalStatusBoolHandler: (() -> (result: Double?, status: Bool))?
+    private(set) var updateResultOptionalDoubleStatusBoolCallCount = 0
+    var updateResultOptionalDoubleStatusBoolHandler: (() -> (result: Double?, status: Bool))?
     func update() -> (result: Double?, status: Bool) {
-        updateResultDoubleOptionalStatusBoolCallCount += 1
-        if let updateResultDoubleOptionalStatusBoolHandler = updateResultDoubleOptionalStatusBoolHandler {
-            return updateResultDoubleOptionalStatusBoolHandler()
+        updateResultOptionalDoubleStatusBoolCallCount += 1
+        if let updateResultOptionalDoubleStatusBoolHandler = updateResultOptionalDoubleStatusBoolHandler {
+            return updateResultOptionalDoubleStatusBoolHandler()
         }
         return (nil, false)
     }