Kolos65 · Kolos65 · Sep 27, 2024 · Sep 27, 2024 · Sep 27, 2024
diff --git a/Sources/Mockable/Documentation/Documentation.docc/Usage.md b/Sources/Mockable/Documentation/Documentation.docc/Usage.md
@@ -197,14 +197,14 @@ You have two options to override the default strict behavior of the library:
     MockerPolicy.default = .relaxedVoid
     ```
 
-The `.relaxedMockable` policy in combination with the [`Mockable`](https://kolos65.github.io/Mockable/documentation/mockable/mockable) protocol can be used to set an implicit return value for custom (or even built in) types:
+The `.relaxedMocked` policy in combination with the [`Mocked`](https://kolos65.github.io/Mockable/documentation/mockable/mocked) protocol can be used to set an implicit return value for custom (or even built in) types:
 ```swift
 struct Car {
     var name: String
     var seats: Int
 }
 
-extension Car: Mockable {
+extension Car: Mocked {
     static var mock: Car {
         Car(name: "Mock Car", seats: 4)
     }
@@ -227,7 +227,7 @@ protocol CarService {
 
 func testCarService() {
     func test() {
-        let mock = MockCarService(policy: .relaxedMockable)
+        let mock = MockCarService(policy: .relaxedMocked)
         // Implictly mocked without a given registration:
         let car = mock.getCar()
         let cars = mock.getCars()

diff --git a/Sources/Mockable/Mockable/Mockable.swift → Sources/Mockable/Mocker/Mocked.swift b/Sources/Mockable/Mockable/Mockable.swift → Sources/Mockable/Mocker/Mocked.swift
@@ -1,13 +1,13 @@
 //
-//  Mockable.swift
-//  Mockable
+//  Mocked.swift
+//  Mocked
 //
 //  Created by Kolos Foltanyi on 2024. 04. 03..
 //
 
 /// A protocol that represents auto-mocked types.
 ///
-/// `Mockable` in combination with a `relaxedMockable` option of `MockerPolicy `can be used
+/// `Mocked` in combination with a `relaxedMocked` option of `MockerPolicy `can be used
 /// to set an implicit return value for custom types:
 ///
 /// ```swift
@@ -16,7 +16,7 @@
 ///     var seats: Int
 /// }
 ///
-/// extension Car: Mockable {
+/// extension Car: Mocked {
 ///     static var mock: Car {
 ///         Car(name: "Mock Car", seats: 4)
 ///     }
@@ -39,14 +39,14 @@
 ///
 /// func testCarService() {
 ///     func test() {
-///         let mock = MockCarService(policy: .relaxedMockable)
+///         let mock = MockCarService(policy: .relaxedMocked)
 ///         // Implictly mocked without a given registration:
 ///         let car = mock.getCar()
 ///         let cars = mock.getCars()
 ///     }
 /// }
 /// ```
-public protocol Mockable {
+public protocol Mocked {
     /// A default mock return value to use when `.relaxedMocked` policy is set.
     static var mock: Self { get }
 
@@ -55,16 +55,16 @@ public protocol Mockable {
     static var mocks: [Self] { get }
 }
 
-extension Mockable {
+extension Mocked {
     public static var mocks: [Self] { [mock] }
 }
 
-extension Array: Mockable where Element: Mockable {
+extension Array: Mocked where Element: Mocked {
     public static var mock: Self {
         Element.mocks
     }
 }
 
-extension Optional: Mockable where Wrapped: Mockable {
+extension Optional: Mocked where Wrapped: Mocked {
     public static var mock: Self { Wrapped.mock }
 }
diff --git a/Sources/Mockable/Mocker/Mocker.swift b/Sources/Mockable/Mocker/Mocker.swift
@@ -358,8 +358,8 @@ extension Mocker {
     public func mock<V>(
         _ member: Member,
         producerResolver: (Any) throws -> V
-    ) -> V where V: Mockable {
-        let relaxed = currentPolicy.contains(.relaxedMockable)
+    ) -> V where V: Mocked {
+        let relaxed = currentPolicy.contains(.relaxedMocked)
         // swiftlint:disable:next force_try
         return try! mock(member, producerResolver, relaxed ? .value(.mock) : .none)
     }
@@ -374,8 +374,8 @@ extension Mocker {
     public func mockThrowing<V>(
         _ member: Member,
         producerResolver: (Any) throws -> V
-    ) throws -> V where V: Mockable {
-        let relaxed = currentPolicy.contains(.relaxedMockable)
+    ) throws -> V where V: Mocked {
+        let relaxed = currentPolicy.contains(.relaxedMocked)
         return try mock(member, producerResolver, relaxed ? .value(.mock) : .none)
     }
 }
@@ -393,9 +393,9 @@ extension Mocker {
     public func mock<V>(
         _ member: Member,
         producerResolver: (Any) throws -> V
-    ) -> V where V: Mockable, V: ExpressibleByNilLiteral {
+    ) -> V where V: Mocked, V: ExpressibleByNilLiteral {
         // swiftlint:disable force_try
-        if currentPolicy.contains(.relaxedMockable) {
+        if currentPolicy.contains(.relaxedMocked) {
             return try! mock(member, producerResolver, .value(.mock))
         } else if currentPolicy.contains(.relaxedOptional) {
             return try! mock(member, producerResolver, .value(nil))
@@ -415,8 +415,8 @@ extension Mocker {
     public func mockThrowing<V>(
         _ member: Member,
         producerResolver: (Any) throws -> V
-    ) throws -> V where V: Mockable, V: ExpressibleByNilLiteral {
-        if currentPolicy.contains(.relaxedMockable) {
+    ) throws -> V where V: Mocked, V: ExpressibleByNilLiteral {
+        if currentPolicy.contains(.relaxedMocked) {
             return try mock(member, producerResolver, .value(.mock))
         } else if currentPolicy.contains(.relaxedOptional) {
             return try mock(member, producerResolver, .value(nil))

diff --git a/Sources/Mockable/Mocker/MockerPolicy.swift b/Sources/Mockable/Mocker/MockerPolicy.swift
@@ -23,7 +23,7 @@ public struct MockerPolicy: OptionSet {
         .relaxedOptional,
         .relaxedThrowingVoid,
         .relaxedNonThrowingVoid,
-        .relaxedMockable
+        .relaxedMocked
     ]
 
     /// Every void function will run normally without a registration
@@ -41,8 +41,8 @@ public struct MockerPolicy: OptionSet {
     /// Optional return values will default to nil.
     public static let relaxedOptional = Self(rawValue: 1 << 2)
 
    /// Types conforming to the `Mockable` protocol will default to their mock value.
-    public static let relaxedMockable = Self(rawValue: 1 << 3)
+    /// Types conforming to the `Mocked` protocol will default to their mock value.
+    public static let relaxedMocked = Self(rawValue: 1 << 3)
 
     /// Option set raw value.
     public let rawValue: Int

diff --git a/Sources/MockableMacro/Factory/Buildable/Function+Buildable.swift b/Sources/MockableMacro/Factory/Buildable/Function+Buildable.swift
@@ -86,7 +86,8 @@ extension FunctionRequirement {
             }
         }
         return ReturnClauseSyntax(
-            type: IdentifierTypeSyntax(
+            type: MemberTypeSyntax(
+                baseType: IdentifierTypeSyntax(name: NS.Mockable),
                 name: name,
                 genericArgumentClause: .init(arguments: arguments)
             )

diff --git a/Sources/MockableMacro/Factory/Buildable/Variable+Buildable.swift b/Sources/MockableMacro/Factory/Buildable/Variable+Buildable.swift
@@ -91,7 +91,7 @@ extension VariableRequirement {
     private func returnType(
         for kind: BuilderKind,
         using mockType: IdentifierTypeSyntax
-    ) throws -> IdentifierTypeSyntax {
+    ) throws -> MemberTypeSyntax {
         let name = if syntax.isComputed {
             try syntax.isThrowing ? NS.ThrowingFunction(kind) : NS.Function(kind)
         } else {
@@ -108,7 +108,9 @@ extension VariableRequirement {
                 produceType
             }
         }
-        return IdentifierTypeSyntax(
+
+        return MemberTypeSyntax(
+            baseType: IdentifierTypeSyntax(name: NS.Mockable),
             name: name,
             genericArgumentClause: .init(arguments: arguments)
         )

diff --git a/Sources/MockableMacro/Factory/BuilderFactory.swift b/Sources/MockableMacro/Factory/BuilderFactory.swift
@@ -37,8 +37,14 @@ extension BuilderFactory {
     }
 
     private static func inheritedTypes(_ kind: BuilderKind) -> InheritedTypeListSyntax {
-        let effectBuilder = IdentifierTypeSyntax(name: NS.EffectBuilder)
-        let assertionBuilder = IdentifierTypeSyntax(name: NS.AssertionBuilder)
+        let effectBuilder = MemberTypeSyntax(
+            baseType: IdentifierTypeSyntax(name: NS.Mockable),
+            name: NS.EffectBuilder
+        )
+        let assertionBuilder = MemberTypeSyntax(
+            baseType: IdentifierTypeSyntax(name: NS.Mockable),
+            name: NS.AssertionBuilder
+        )
         return [InheritedTypeSyntax(type: kind == .verify ? assertionBuilder : effectBuilder)]
     }
 
@@ -77,7 +83,7 @@ extension BuilderFactory {
             bindingsBuilder: {
                 PatternBindingSyntax(
                     pattern: IdentifierPatternSyntax(identifier: NS.mocker),
-                    typeAnnotation: TypeAnnotationSyntax(type: mockerType(requirements))
+                    typeAnnotation: TypeAnnotationSyntax(type: IdentifierTypeSyntax(name: NS.Mocker))
                 )
             }
         )
@@ -131,7 +137,10 @@ extension BuilderFactory {
     ) -> FunctionSignatureSyntax {
         FunctionSignatureSyntax(
             parameterClause: FunctionParameterClauseSyntax {
-                FunctionParameterSyntax(firstName: NS.mocker, type: mockerType(requirements))
+                FunctionParameterSyntax(
+                    firstName: NS.mocker,
+                    type: IdentifierTypeSyntax(name: NS.Mocker)
+                )
                 if kind == .verify {
                     FunctionParameterSyntax(
                         firstName: NS.assertion,
@@ -142,16 +151,10 @@ extension BuilderFactory {
         )
     }
 
-    private static func mockerType(_ requirements: Requirements) -> IdentifierTypeSyntax {
-        IdentifierTypeSyntax(
-            name: NS.Mocker,
-            genericArgumentClause: GenericArgumentClauseSyntax(arguments: [
-                GenericArgumentSyntax(argument: requirements.syntax.mockType)
-            ])
+    private static var assertionType: MemberTypeSyntax {
+        MemberTypeSyntax(
+            baseType: IdentifierTypeSyntax(name: NS.Mockable),
+            name: NS.MockableAssertion
         )
     }
-
-    private static var assertionType: IdentifierTypeSyntax {
-        IdentifierTypeSyntax(name: NS.MockableAssertion)
-    }
 }
diff --git a/Sources/MockableMacro/Factory/EnumFactory.swift b/Sources/MockableMacro/Factory/EnumFactory.swift
@@ -27,8 +27,18 @@ enum EnumFactory: Factory {
 extension EnumFactory {
     private static var inheritanceClause: InheritanceClauseSyntax {
         InheritanceClauseSyntax {
-            InheritedTypeSyntax(type: IdentifierTypeSyntax(name: NS.Matchable))
-            InheritedTypeSyntax(type: IdentifierTypeSyntax(name: NS.CaseIdentifiable))
+            InheritedTypeSyntax(
+                type: MemberTypeSyntax(
+                    baseType: IdentifierTypeSyntax(name: NS.Mockable),
+                    name: NS.Matchable
+                )
+            )
+            InheritedTypeSyntax(
+                type: MemberTypeSyntax(
+                    baseType: IdentifierTypeSyntax(name: NS.Mockable),
+                    name: NS.CaseIdentifiable
+                )
+            )
         }
     }
 

diff --git a/Sources/MockableMacro/Factory/MemberFactory.swift b/Sources/MockableMacro/Factory/MemberFactory.swift
@@ -14,6 +14,7 @@ import SwiftSyntax
 enum MemberFactory: Factory {
     static func build(from requirements: Requirements) throws -> MemberBlockItemListSyntax {
         MemberBlockItemListSyntax {
+            mockerAlias(requirements)
             mocker(requirements)
             given(requirements)
             when(requirements)
@@ -35,6 +36,24 @@ extension MemberFactory {
         )
     }
 
+    private static func mockerAlias(_ requirements: Requirements) -> TypeAliasDeclSyntax {
+        TypeAliasDeclSyntax(
+            modifiers: requirements.modifiers,
+            name: NS.Mocker,
+            initializer: TypeInitializerClauseSyntax(
+                value: MemberTypeSyntax(
+                    baseType: IdentifierTypeSyntax(name: NS.Mockable),
+                    name: NS.Mocker,
+                    genericArgumentClause: GenericArgumentClauseSyntax(
+                        arguments: GenericArgumentListSyntax {
+                            GenericArgumentSyntax(argument: requirements.syntax.mockType)
+                        }
+                    )
+                )
+            )
+        )
+    }
+
     private static func mocker(_ requirements: Requirements) -> VariableDeclSyntax {
         VariableDeclSyntax(
             modifiers: [DeclModifierSyntax(name: .keyword(.private))],
@@ -44,14 +63,7 @@ extension MemberFactory {
                 pattern: IdentifierPatternSyntax(identifier: NS.mocker),
                 initializer: InitializerClauseSyntax(
                     value: FunctionCallExprSyntax(
-                        calledExpression: GenericSpecializationExprSyntax(
-                            expression: DeclReferenceExprSyntax(baseName: NS.Mocker),
-                            genericArgumentClause: GenericArgumentClauseSyntax(
-                                arguments: GenericArgumentListSyntax {
-                                    GenericArgumentSyntax(argument: requirements.syntax.mockType)
-                                }
-                            )
-                        ),
+                        calledExpression: DeclReferenceExprSyntax(baseName: NS.Mocker),
                         leftParen: .leftParenToken(),
                         arguments: [],
                         rightParen: .rightParenToken()
@@ -164,7 +176,10 @@ extension MemberFactory {
             secondName: NS.assertion,
             type: AttributedTypeSyntax(
                 attributes: [.attribute(.escaping)],
-                baseType: IdentifierTypeSyntax(name: NS.MockableAssertion)
+                baseType: MemberTypeSyntax(
+                    baseType: IdentifierTypeSyntax(name: NS.Mockable),
+                    name: NS.MockableAssertion
+                )
             )
         )
     }
@@ -178,7 +193,8 @@ extension MemberFactory {
                 genericArgumentClause: GenericArgumentClauseSyntax(
                     arguments: GenericArgumentListSyntax {
                         GenericArgumentSyntax(
-                            argument: IdentifierTypeSyntax(
+                            argument: MemberTypeSyntax(
+                                baseType: IdentifierTypeSyntax(name: NS.Mockable),
                                 name: NS.MockerScope
                             )
                         )
@@ -246,7 +262,10 @@ extension MemberFactory {
                 FunctionParameterSyntax(
                     firstName: NS.policy,
                     type: OptionalTypeSyntax(
-                        wrappedType: IdentifierTypeSyntax(name: NS.MockerPolicy)
+                        wrappedType: MemberTypeSyntax(
+                            baseType: IdentifierTypeSyntax(name: NS.Mockable),
+                            name: NS.MockerPolicy
+                        )
                     ),
                     defaultValue: InitializerClauseSyntax(
                         value: NilLiteralExprSyntax()

diff --git a/Sources/MockableMacro/Factory/MockFactory.swift b/Sources/MockableMacro/Factory/MockFactory.swift
@@ -60,9 +60,12 @@ extension MockFactory {
             InheritedTypeSyntax(type: IdentifierTypeSyntax(
                 name: requirements.syntax.name.trimmed
             ))
-            InheritedTypeSyntax(type: IdentifierTypeSyntax(
-                name: NS.MockableService
-            ))
+            InheritedTypeSyntax(
+                type: MemberTypeSyntax(
+                    baseType: IdentifierTypeSyntax(name: NS.Mockable),
+                    name: NS.MockableService
+                )
+            )
         }
     }
 

diff --git a/Sources/MockableMacro/Utils/Namespace.swift b/Sources/MockableMacro/Utils/Namespace.swift
@@ -56,6 +56,7 @@ enum NS {
     static let mocker: TokenSyntax = "mocker"
     static let assertion: TokenSyntax = "assertion"
 
+    static let Mockable: TokenSyntax = "Mockable"
     static let Mock: TokenSyntax = "Mock"
     static let MockableService: TokenSyntax = "MockableService"
     static let Bool: TokenSyntax = "Bool"