Inherit protocol modifiers

Sources/SpyableMacro/Extensions/VariableDeclSyntax+Applying.swift

@@ -0,0 +1,9 @@
+import SwiftSyntax
+
+extension VariableDeclSyntax {
+  func applying(modifiers: DeclModifierListSyntax) -> VariableDeclSyntax {
+    var copy = self
+    copy.modifiers = modifiers
+    return copy
+  }
+}

Sources/SpyableMacro/Factories/CalledFactory.swift

@@ -25,13 +25,16 @@ import SwiftSyntaxBuilder
 /// ```
 /// and an argument `variablePrefix` equal to `foo`.
 struct CalledFactory {
-  func variableDeclaration(variablePrefix: String) throws -> VariableDeclSyntax {
+  func variableDeclaration(modifiers: DeclModifierListSyntax, variablePrefix: String) throws
+    -> VariableDeclSyntax
+  {
     try VariableDeclSyntax(
       """
       var \(raw: variablePrefix)Called: Bool {
           return \(raw: variablePrefix)CallsCount > 0
       }
       """
     )
+    .applying(modifiers: modifiers)
   }
 }

Sources/SpyableMacro/Factories/CallsCountFactory.swift

@@ -21,12 +21,15 @@ import SwiftSyntaxBuilder
 /// ```
 /// and an argument `variablePrefix` equal to `foo`.
 struct CallsCountFactory {
-  func variableDeclaration(variablePrefix: String) throws -> VariableDeclSyntax {
+  func variableDeclaration(modifiers: DeclModifierListSyntax, variablePrefix: String) throws
+    -> VariableDeclSyntax
+  {
     try VariableDeclSyntax(
       """
       var \(variableIdentifier(variablePrefix: variablePrefix)) = 0
       """
     )
+    .applying(modifiers: modifiers)
   }
 
   func incrementVariableExpression(variablePrefix: String) -> ExprSyntax {

Sources/SpyableMacro/Factories/ClosureFactory.swift

@@ -29,6 +29,7 @@ import SwiftSyntaxBuilder
 ///         interacts correctly with the function.
 struct ClosureFactory {
   func variableDeclaration(
+    modifiers: DeclModifierListSyntax,
     variablePrefix: String,
     functionSignature: FunctionSignatureSyntax
   ) throws -> VariableDeclSyntax {
@@ -59,6 +60,7 @@ struct ClosureFactory {
       var \(variableIdentifier(variablePrefix: variablePrefix)): (\(elements))?
       """
     )
+    .applying(modifiers: modifiers)
   }
 
   func callExpression(

Sources/SpyableMacro/Factories/FunctionImplementationFactory.swift

@@ -64,12 +64,20 @@ struct FunctionImplementationFactory {
   private let returnValueFactory = ReturnValueFactory()
 
   func declaration(
+    modifiers: DeclModifierListSyntax,
     variablePrefix: String,
     protocolFunctionDeclaration: FunctionDeclSyntax
   ) -> FunctionDeclSyntax {
     var spyFunctionDeclaration = protocolFunctionDeclaration
 
-    spyFunctionDeclaration.modifiers = protocolFunctionDeclaration.modifiers.removingMutatingKeyword
+    spyFunctionDeclaration.modifiers = DeclModifierListSyntax {
+      for protoModifier in modifiers {
+        protoModifier
+      }
+      for functionModifier in protocolFunctionDeclaration.modifiers.removingMutatingKeyword {
+        functionModifier
+      }
+    }
 
     spyFunctionDeclaration.body = CodeBlockSyntax {
       let parameterList = protocolFunctionDeclaration.signature.parameterClause.parameters

Sources/SpyableMacro/Factories/ReceivedArgumentsFactory.swift

@@ -37,6 +37,7 @@ import SwiftSyntaxBuilder
 /// and an argument `variablePrefix` equal to `bar`.
 struct ReceivedArgumentsFactory {
   func variableDeclaration(
+    modifiers: DeclModifierListSyntax,
     variablePrefix: String,
     parameterList: FunctionParameterListSyntax
   ) throws -> VariableDeclSyntax {
@@ -51,6 +52,7 @@ struct ReceivedArgumentsFactory {
       var \(identifier): \(type)
       """
     )
+    .applying(modifiers: modifiers)
   }
 
   private func variableType(parameterList: FunctionParameterListSyntax) -> TypeSyntaxProtocol {

Sources/SpyableMacro/Factories/ReceivedInvocationsFactory.swift

@@ -42,6 +42,7 @@ import SwiftSyntaxBuilder
 ///         about the arguments in the last invocation, use `ReceivedArgumentsFactory`.
 struct ReceivedInvocationsFactory {
   func variableDeclaration(
+    modifiers: DeclModifierListSyntax,
     variablePrefix: String,
     parameterList: FunctionParameterListSyntax
   ) throws -> VariableDeclSyntax {
@@ -53,6 +54,7 @@ struct ReceivedInvocationsFactory {
       var \(identifier): [\(elementType)] = []
       """
     )
+    .applying(modifiers: modifiers)
   }
 
   private func arrayElementType(parameterList: FunctionParameterListSyntax) -> TypeSyntaxProtocol {

Sources/SpyableMacro/Factories/ReturnValueFactory.swift

@@ -39,6 +39,7 @@ import SwiftSyntaxBuilder
 ///         correctly to different returned values.
 struct ReturnValueFactory {
   func variableDeclaration(
+    modifiers: DeclModifierListSyntax,
     variablePrefix: String,
     functionReturnType: TypeSyntax
   ) throws -> VariableDeclSyntax {
@@ -56,6 +57,7 @@ struct ReturnValueFactory {
       var \(variableIdentifier(variablePrefix: variablePrefix))\(typeAnnotation)
       """
     )
+    .applying(modifiers: modifiers)
   }
 
   func returnStatement(variablePrefix: String) -> StmtSyntax {

Sources/SpyableMacro/Factories/SpyFactory.swift

@@ -107,7 +107,10 @@ struct SpyFactory {
     let functionDeclarations = protocolDeclaration.memberBlock.members
       .compactMap { $0.decl.as(FunctionDeclSyntax.self)?.removingLeadingSpaces }
 
+    let memberModifiers = protocolDeclaration.modifiers.replacingPrivateWithFileprivate
+
     return try ClassDeclSyntax(
+      modifiers: protocolDeclaration.modifiers,
       name: identifier,
       genericParameterClause: genericParameterClause,
       inheritanceClause: InheritanceClauseSyntax {
@@ -116,8 +119,15 @@ struct SpyFactory {
         )
       },
       memberBlockBuilder: {
+        InitializerDeclSyntax(
+          modifiers: memberModifiers,
+          signature: FunctionSignatureSyntax(parameterClause: .init(parameters: [])),
+          body: CodeBlockSyntax(statements: [])
+        )
+
         for variableDeclaration in variableDeclarations {
           try variablesImplementationFactory.variablesDeclarations(
+            modifiers: memberModifiers,
             protocolVariableDeclaration: variableDeclaration
           )
         }
@@ -126,37 +136,45 @@ struct SpyFactory {
           let variablePrefix = variablePrefixFactory.text(for: functionDeclaration)
           let parameterList = functionDeclaration.signature.parameterClause.parameters
 
-          try callsCountFactory.variableDeclaration(variablePrefix: variablePrefix)
-          try calledFactory.variableDeclaration(variablePrefix: variablePrefix)
+          try callsCountFactory.variableDeclaration(
+            modifiers: memberModifiers, variablePrefix: variablePrefix)
+          try calledFactory.variableDeclaration(
+            modifiers: memberModifiers, variablePrefix: variablePrefix)
 
           if parameterList.supportsParameterTracking {
             try receivedArgumentsFactory.variableDeclaration(
+              modifiers: memberModifiers,
               variablePrefix: variablePrefix,
               parameterList: parameterList
             )
             try receivedInvocationsFactory.variableDeclaration(
+              modifiers: memberModifiers,
               variablePrefix: variablePrefix,
               parameterList: parameterList
             )
           }
 
           if functionDeclaration.signature.effectSpecifiers?.throwsSpecifier != nil {
-            try throwableErrorFactory.variableDeclaration(variablePrefix: variablePrefix)
+            try throwableErrorFactory.variableDeclaration(
+              modifiers: memberModifiers, variablePrefix: variablePrefix)
           }
 
           if let returnType = functionDeclaration.signature.returnClause?.type {
             try returnValueFactory.variableDeclaration(
+              modifiers: memberModifiers,
               variablePrefix: variablePrefix,
               functionReturnType: returnType
             )
           }
 
           try closureFactory.variableDeclaration(
+            modifiers: memberModifiers,
             variablePrefix: variablePrefix,
             functionSignature: functionDeclaration.signature
           )
 
           functionImplementationFactory.declaration(
+            modifiers: memberModifiers,
             variablePrefix: variablePrefix,
             protocolFunctionDeclaration: functionDeclaration
           )
@@ -185,3 +203,16 @@ extension SyntaxProtocol {
     )
   }
 }
+
+extension DeclModifierListSyntax {
+  fileprivate var replacingPrivateWithFileprivate: Self {
+    DeclModifierListSyntax(
+      map {
+        if $0.name.text == TokenSyntax.keyword(.private).text {
+          return .init(name: .keyword(.fileprivate))
+        } else {
+          return $0
+        }
+      })
+  }
+}

Sources/SpyableMacro/Factories/ThrowableErrorFactory.swift

@@ -29,12 +29,15 @@ import SwiftSyntaxBuilder
 ///         your tests. You can use it to simulate different scenarios and verify that your code handles
 ///         errors correctly.
 struct ThrowableErrorFactory {
-  func variableDeclaration(variablePrefix: String) throws -> VariableDeclSyntax {
+  func variableDeclaration(modifiers: DeclModifierListSyntax, variablePrefix: String) throws
+    -> VariableDeclSyntax
+  {
     try VariableDeclSyntax(
       """
       var \(variableIdentifier(variablePrefix: variablePrefix)): (any Error)?
       """
     )
+    .applying(modifiers: modifiers)
   }
 
   func throwErrorExpression(variablePrefix: String) -> ExprSyntax {

Sources/SpyableMacro/Factories/VariablesImplementationFactory.swift

@@ -47,18 +47,23 @@ struct VariablesImplementationFactory {
 
   @MemberBlockItemListBuilder
   func variablesDeclarations(
+    modifiers: DeclModifierListSyntax,
     protocolVariableDeclaration: VariableDeclSyntax
   ) throws -> MemberBlockItemListSyntax {
     if protocolVariableDeclaration.bindings.count == 1 {
       // Since the count of `bindings` is exactly 1, it is safe to force unwrap it.
       let binding = protocolVariableDeclaration.bindings.first!
 
       if binding.typeAnnotation?.type.is(OptionalTypeSyntax.self) == true {
-        accessorRemovalVisitor.visit(protocolVariableDeclaration)
+        if let variableDecl = accessorRemovalVisitor.visit(protocolVariableDeclaration).as(
+          VariableDeclSyntax.self)
+        {
+          variableDecl.applying(modifiers: modifiers)
+        }
       } else {
-        try protocolVariableDeclarationWithGetterAndSetter(binding: binding)
+        try protocolVariableDeclarationWithGetterAndSetter(modifiers: modifiers, binding: binding)
 
-        try underlyingVariableDeclaration(binding: binding)
+        try underlyingVariableDeclaration(modifiers: modifiers, binding: binding)
       }
     } else {
       // As far as I know variable declaration in a protocol should have exactly one binding.
@@ -67,6 +72,7 @@ struct VariablesImplementationFactory {
   }
 
   private func protocolVariableDeclarationWithGetterAndSetter(
+    modifiers: DeclModifierListSyntax,
     binding: PatternBindingSyntax
   ) throws -> VariableDeclSyntax {
     try VariableDeclSyntax(
@@ -77,16 +83,19 @@ struct VariablesImplementationFactory {
       }
       """
     )
+    .applying(modifiers: modifiers)
   }
 
   private func underlyingVariableDeclaration(
+    modifiers: DeclModifierListSyntax,
     binding: PatternBindingListSyntax.Element
   ) throws -> VariableDeclSyntax {
     try VariableDeclSyntax(
       """
       var \(raw: underlyingVariableName(binding: binding)): (\(binding.typeAnnotation!.type.trimmed))!
       """
     )
+    .applying(modifiers: modifiers)
   }
 
   private func underlyingVariableName(binding: PatternBindingListSyntax.Element) throws -> String {

Tests/SpyableMacroTests/Factories/UT_CalledFactory.swift

@@ -10,7 +10,8 @@ final class UT_CalledFactory: XCTestCase {
   func testVariableDeclaration() throws {
     let variablePrefix = "functionName"
 
-    let result = try CalledFactory().variableDeclaration(variablePrefix: variablePrefix)
+    let result = try CalledFactory().variableDeclaration(
+      modifiers: [], variablePrefix: variablePrefix)
 
     assertBuildResult(
       result,
@@ -21,4 +22,20 @@ final class UT_CalledFactory: XCTestCase {
       """
     )
   }
+
+  func testVariableDeclarationWithAccess() throws {
+    let variablePrefix = "functionName"
+
+    let result = try CalledFactory().variableDeclaration(
+      modifiers: [.init(name: "public")], variablePrefix: variablePrefix)
+
+    assertBuildResult(
+      result,
+      """
+      public var functionNameCalled: Bool {
+          return functionNameCallsCount > 0
+      }
+      """
+    )
+  }
 }

Tests/SpyableMacroTests/Factories/UT_CallsCountFactory.swift

@@ -10,7 +10,8 @@ final class UT_CallsCountFactory: XCTestCase {
   func testVariableDeclaration() throws {
     let variablePrefix = "functionName"
 
-    let result = try CallsCountFactory().variableDeclaration(variablePrefix: variablePrefix)
+    let result = try CallsCountFactory().variableDeclaration(
+      modifiers: [], variablePrefix: variablePrefix)
 
     assertBuildResult(
       result,
@@ -20,6 +21,20 @@ final class UT_CallsCountFactory: XCTestCase {
     )
   }
 
+  func testVariableDeclarationWithAccess() throws {
+    let variablePrefix = "functionName"
+
+    let result = try CallsCountFactory().variableDeclaration(
+      modifiers: [.init(name: "public")], variablePrefix: variablePrefix)
+
+    assertBuildResult(
+      result,
+      """
+      public var functionNameCallsCount = 0
+      """
+    )
+  }
+
   // MARK: - Variable Expression
 
   func testIncrementVariableExpression() {

Tests/SpyableMacroTests/Factories/UT_ClosureFactory.swift

@@ -136,6 +136,7 @@ final class UT_ClosureFactory: XCTestCase {
     let protocolFunctionDeclaration = try FunctionDeclSyntax("\(raw: functionDeclaration)") {}
 
     let result = try ClosureFactory().variableDeclaration(
+      modifiers: [],
       variablePrefix: variablePrefix,
       functionSignature: protocolFunctionDeclaration.signature
     )

Tests/SpyableMacroTests/Factories/UT_FunctionImplementationFactory.swift

@@ -20,6 +20,19 @@ final class UT_FunctionImplementationFactory: XCTestCase {
     )
   }
 
+  func testDeclarationAccessModifiers() throws {
+    try assertProtocolFunction(
+      withFunctionDeclaration: "public func foo()",
+      prefixForVariable: "_prefix_",
+      expectingFunctionDeclaration: """
+        public func foo() {
+            _prefix_CallsCount += 1
+            _prefix_Closure?()
+        }
+        """
+    )
+  }
+
   func testDeclarationArguments() throws {
     try assertProtocolFunction(
       withFunctionDeclaration: "func foo(text: String, count: Int)",
@@ -129,6 +142,7 @@ final class UT_FunctionImplementationFactory: XCTestCase {
     let protocolFunctionDeclaration = try FunctionDeclSyntax("\(raw: functionDeclaration)") {}
 
     let result = FunctionImplementationFactory().declaration(
+      modifiers: [],
       variablePrefix: variablePrefix,
       protocolFunctionDeclaration: protocolFunctionDeclaration
     )