Compile fixture code with macro

Package.swift

@@ -1,10 +1,11 @@
-// swift-tools-version:5.7
+// swift-tools-version:5.10
+import CompilerPluginSupport
 import PackageDescription
 
 let package = Package(
     name: "Mockolo",
     platforms: [
-        .macOS(.v12),
+        .macOS(.v13),
     ],
     products: [
         .executable(name: "mockolo", targets: ["Mockolo"]),
@@ -21,7 +22,8 @@ let package = Package(
             dependencies: [
                 "MockoloFramework",
                 .product(name: "ArgumentParser", package: "swift-argument-parser"),
-            ]),
+            ]
+        ),
         .target(
             name: "MockoloFramework",
             dependencies: [
@@ -30,12 +32,21 @@ let package = Package(
                 .product(name: "Algorithms", package: "swift-algorithms"),
             ]
         ),
+        .macro(
+            name: "MockoloTestSupportMacros",
+            dependencies: [
+                .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
+                .product(name: "SwiftDiagnostics", package: "swift-syntax"),
+                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+            ]
+        ),
         .testTarget(
             name: "MockoloTests",
             dependencies: [
                 "MockoloFramework",
+                "MockoloTestSupportMacros",
             ],
             path: "Tests"
-        )
+        ),
     ]
 )

README.md

@@ -21,9 +21,9 @@ This project may contain unstable APIs which may not be ready for general use. S
 
 ## System Requirements
 
-* Swift 5.7 or later
-* Xcode 14.2 or later
-* macOS 12.0 or later and Linux
+* Swift 5.10 or later
+* Xcode 15.3 or later
+* macOS 13.0 or later and Linux
 * Support is included for the Swift Package Manager
 
 
@@ -424,11 +424,6 @@ This will generate:
 public class FooMock: FooProtocol { ... }
 ```
 
-## Used libraries
-
-[SwiftSyntax](https://github.com/apple/swift-syntax) |
-
-
 ## How to contribute to Mockolo
 See [CONTRIBUTING](CONTRIBUTING.md) for more info.
 

Sources/Mockolo/Executor.swift

@@ -214,10 +214,8 @@ struct Executor: ParsableCommand {
                          excludeImports: excludeImports,
                          to: outputFilePath,
                          loggingLevel: loggingLevel,
-                         concurrencyLimit: concurrencyLimit,
-                         onCompletion: { _ in
-                    log("Done. Exiting program.", level: .info)
-            })
+                         concurrencyLimit: concurrencyLimit)
+            log("Done. Exiting program.", level: .info)
         } catch {
             fatalError("Generation error: \(error)")
         }

Sources/MockoloFramework/Operations/Generator.swift

@@ -23,6 +23,7 @@ enum InputError: Error {
 }
 
 /// Performs end to end mock generation flow
+@discardableResult
 public func generate(sourceDirs: [String],
                      sourceFiles: [String],
                      parser: SourceParser,
@@ -43,8 +44,7 @@ public func generate(sourceDirs: [String],
                      excludeImports: [String],
                      to outputFilePath: String,
                      loggingLevel: Int,
-                     concurrencyLimit: Int?,
-                     onCompletion: @escaping (String) -> ()) throws {
+                     concurrencyLimit: Int?) throws -> String {
     guard sourceDirs.count > 0 || sourceFiles.count > 0 else {
         log("Source files or directories do not exist", level: .error)
         throw InputError.sourceFilesError
@@ -184,5 +184,5 @@ public func generate(sourceDirs: [String],
     log("TOTAL", t5-t0, level: .verbose)
     log("#Protocols = \(protocolMap.count), #Annotated protocols = \(annotatedProtocolMap.count), #Parent mock classes = \(parentMocks.count), #Final mock classes = \(candidates.count), File LoC = \(count)", level: .verbose)
 
-    onCompletion(result)
+    return result
 }

Sources/MockoloTestSupportMacros/Fixture.swift

@@ -0,0 +1,49 @@
+import SwiftBasicFormat
+import SwiftSyntax
+import SwiftSyntaxMacros
+
+struct Fixture: MemberMacro {
+    static func expansion(
+        of node: AttributeSyntax,
+        providingMembersOf declaration: some DeclGroupSyntax,
+        conformingTo protocols: [TypeSyntax],
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        let baseItems = declaration.memberBlock.members.filter { (item: MemberBlockItemSyntax) in
+            if let decl = item.decl.asProtocol(WithAttributesSyntax.self) {
+                let isFixtureAnnotated = decl.attributes.contains { (attr: AttributeListSyntax.Element) in
+                    return attr.trimmedDescription == "@Fixture"
+                }
+                return !isFixtureAnnotated
+            }
+            return true
+        }
+
+        let indent = BasicFormat.inferIndentation(of: declaration) ?? .spaces(4)
+        let sourceContent = baseItems.trimmedDescription(matching: \.isNewline)
+
+        let varDecl = VariableDeclSyntax(
+            modifiers: [.init(name: .keyword(.static))],
+            .let,
+            name: "_source",
+            initializer: .init(
+                value: StringLiteralExprSyntax(
+                    multilineContent: sourceContent,
+                    endIndent: Trivia(pieces: node.leadingTrivia.filter(\.isSpaceOrTab)) + indent
+                )
+            )
+        )
+
+        return [DeclSyntax(varDecl)]
+    }
+}
+
+extension StringLiteralExprSyntax {
+    fileprivate init(multilineContent: String, endIndent: Trivia) {
+        self = StringLiteralExprSyntax(
+            openingQuote: .multilineStringQuoteToken(),
+            segments: [.stringSegment(.init(content: .stringSegment(multilineContent)))],
+            closingQuote: .multilineStringQuoteToken(leadingTrivia: endIndent)
+        )
+    }
+}

Sources/MockoloTestSupportMacros/MacroMain.swift

@@ -0,0 +1,8 @@
+import SwiftCompilerPlugin
+import SwiftSyntaxMacros
+
+@main struct MacroMain: CompilerPlugin {
+    let providingMacros: [any Macro.Type] = [
+        Fixture.self,
+    ]
+}

Tests/MockoloTestCase.swift

@@ -132,13 +132,14 @@ class MockoloTestCase: XCTestCase {
                      excludeImports: [],
                      to: dstFilePath,
                      loggingLevel: 3,
-                     concurrencyLimit: concurrencyLimit,
-                     onCompletion: { ret in
-            let output = (try? String(contentsOf: URL(fileURLWithPath: self.defaultDstFilePath), encoding: .utf8)) ?? ""
-            let outputContents = output.components(separatedBy:  .newlines).filter { !$0.isEmpty && !$0.allSatisfy(\.isWhitespace) }
-            let fixtureContents = dstContent.components(separatedBy: .newlines).filter { !$0.isEmpty && !$0.allSatisfy(\.isWhitespace) }
-            XCTAssert(outputContents.contains(subArray: fixtureContents), "output:\n" + output)
-        })
+                     concurrencyLimit: concurrencyLimit)
+        let output = (try? String(contentsOf: URL(fileURLWithPath: self.defaultDstFilePath), encoding: .utf8)) ?? ""
+        let outputContents = output.components(separatedBy:  .newlines).filter { !$0.isEmpty && !$0.allSatisfy(\.isWhitespace) }
+        let fixtureContents = dstContent.components(separatedBy: .newlines).filter { !$0.isEmpty && !$0.allSatisfy(\.isWhitespace) }
+        if fixtureContents.isEmpty {
+            throw XCTSkip("empty fixture")
+        }
+        XCTAssert(outputContents.contains(subArray: fixtureContents), "output:\n" + output)
     }
 }
 

Tests/TestActor/ActorTests.swift

@@ -1,22 +1,22 @@
 final class ActorTests: MockoloTestCase {
     func testActorProtocol() {
-        verify(srcContent: actorProtocol,
-               dstContent: actorProtocolMock)
+        verify(srcContent: actorProtocol._source,
+               dstContent: actorProtocol.expected._source)
     }
 
     func testParentProtocolInheritsActor() {
-        verify(srcContent: parentProtocolInheritsActor,
-               dstContent: parentProtocolInheritsActorMock)
+        verify(srcContent: parentProtocolInheritsActor._source,
+               dstContent: parentProtocolInheritsActor.expected._source)
     }
 
     func testGlobalActorProtocol() {
-        verify(srcContent: globalActorProtocol,
-               dstContent: globalActorProtocolMock)
+        verify(srcContent: globalActorProtocol._source,
+               dstContent: globalActorProtocol.expected._source)
     }
 
     func testAttributeAboveAnnotationComment() {
-        verify(srcContent: attributeAboveAnnotationComment,
-               dstContent: attributeAboveAnnotationCommentMock,
+        verify(srcContent: attributeAboveAnnotationComment._source,
+               dstContent: attributeAboveAnnotationComment.expected._source,
                declType: .all)
     }
 }

Tests/TestActor/FixtureActor.swift

@@ -1,63 +1,94 @@
-import MockoloFramework
+@Fixture enum actorProtocol {
+    /// @mockable
+    protocol Foo: Actor {
+        func foo(arg: String) async -> Result<String, Error>
+        var bar: Int { get }
+    }
 
-let actorProtocol = """
-/// \(String.mockAnnotation)
-protocol Foo: Actor {
-    func foo(arg: String) async -> Result<String, Error>
-    var bar: Int { get }
-}
-"""
-
-let actorProtocolMock = """
-actor FooMock: Foo {
-    init() { }
-    init(bar: Int = 0) {
-        self.bar = bar
-    }
-    private(set) var fooCallCount = 0
-    var fooHandler: ((String) async -> Result<String, Error>)?
-    func foo(arg: String) async -> Result<String, Error> {
-        fooCallCount += 1
-        if let fooHandler = fooHandler {
-            return await fooHandler(arg)
+    @Fixture enum expected {
+        actor FooMock: Foo {
+            init() { }
+            init(bar: Int = 0) {
+                self.bar = bar
+            }
+            private(set) var fooCallCount = 0
+            var fooHandler: ((String) async -> Result<String, Error>)?
+            func foo(arg: String) async -> Result<String, Error> {
+                fooCallCount += 1
+                if let fooHandler = fooHandler {
+                    return await fooHandler(arg)
+                }
+                fatalError("fooHandler returns can't have a default value thus its handler must be set")
+            }
+
+            var bar: Int = 0
         }
-        fatalError("fooHandler returns can't have a default value thus its handler must be set")
     }
-
-    var bar: Int = 0
 }
-"""
 
+@Fixture enum parentProtocolInheritsActor {
+    protocol Bar: Actor {
+        var bar: Int { get }
+    }
+
+    /// @mockable
+    protocol Foo: Bar {
+        func baz(arg: String) async -> Int
+    }
+
+    @Fixture enum expected {
+        actor FooMock: Foo {
+            init() { }
+            init(bar: Int = 0) {
+                self.bar = bar
+            }
 
-let parentProtocolInheritsActor = """
-protocol Bar: Actor {
-    var bar: Int { get }
-}
 
-/// \(String.mockAnnotation)
-protocol Foo: Bar {
-    func baz(arg: String) async -> Int
+            var bar: Int = 0
+
+            private(set) var bazCallCount = 0
+            var bazHandler: ((String) async -> Int)?
+            func baz(arg: String) async -> Int {
+                bazCallCount += 1
+                if let bazHandler = bazHandler {
+                    return await bazHandler(arg)
+                }
+                return 0
+            }
+        }
+    }
 }
-"""
 
-let parentProtocolInheritsActorMock = """
-actor FooMock: Foo {
-    init() { }
-    init(bar: Int = 0) {
-        self.bar = bar
+@Fixture enum attributeAboveAnnotationComment {
+    @MainActor
+    /// @mockable
+    protocol P0 {
     }
 
+    @MainActor
+    /// @mockable
+    @available(iOS 18.0, *) protocol P1 {
+    }
 
-    var bar: Int = 0
+    @MainActor
+    /// @mockable
+    public class C0 {
+        init() {}
+    }
+
+    @Fixture enum expected {
+        class P0Mock: P0 {
+            init() { }
+        }
+
+        class P1Mock: P1 {
+            init() { }
+        }
 
-    private(set) var bazCallCount = 0
-    var bazHandler: ((String) async -> Int)?
-    func baz(arg: String) async -> Int {
-        bazCallCount += 1
-        if let bazHandler = bazHandler {
-            return await bazHandler(arg)
+        public class C0Mock: C0 {
+            override init() {
+                super.init()
+            }
         }
-        return 0
     }
 }
-"""