Swift Package Index

Build Information

Successful build of swift-mocking, reference main (762fdd), with Swift 6.4 for macOS (SPM) on 26 Sep 2026 03:28:04 UTC.

Swift 6 data race errors: 0

Build Command

env DEVELOPER_DIR=/Applications/Xcode-27.0.0-Release.Candidate.app xcrun swift build --arch arm64

Build Log

========================================
RunAll
========================================
Builder version: 5.1.0
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/fetch-rewards/swift-mocking.git
Reference: main
Initialized empty Git repository in /Users/admin/builder/spi-builder-workspace/.git/
From https://github.com/fetch-rewards/swift-mocking
 * branch            main       -> FETCH_HEAD
 * [new branch]      main       -> origin/main
HEAD is now at 762fdd1 Make imperative PR title check more reliable (#198)
Cloned https://github.com/fetch-rewards/swift-mocking.git
Revision (git rev-parse @):
762fdd18dce9c6e0e75ece0cffce5a57832848ab
SUCCESS checkout https://github.com/fetch-rewards/swift-mocking.git at main
========================================
Build
========================================
Selected platform:         macosSpm
Swift version:             6.4
Building package at path:  $PWD
https://github.com/fetch-rewards/swift-mocking.git
Running build ...
env DEVELOPER_DIR=/Applications/Xcode-27.0.0-Release.Candidate.app xcrun swift build --arch arm64
Building for debugging...
[Computing dependencies]
[Pre-planning 1 / 653]
[Planning deferred tasks]
[122 / 293]
[127 / 296] _SwiftSyntaxCShims
[130 / 304]
[155 / 305] SwiftSyntax510
[161 / 315] SwiftSyntax
[168 / 331]
[172 / 331]
[175 / 331]
[176 / 331]
[187 / 331] SwiftSyntax
[196 / 334] SwiftBasicFormat
[203 / 362] SwiftParser
[219 / 362] SwiftParser
[220 / 362] SwiftParser
[221 / 362] SwiftParser
[224 / 362] SwiftParser
[226 / 362] SwiftParser
[230 / 362] SwiftParser
[235 / 362] SwiftDiagnostics
[237 / 362] SwiftOperators
[241 / 362] SwiftDiagnostics
[244 / 364]
[248 / 375] SwiftOperators
[252 / 386] SwiftParserDiagnostics
[257 / 386] SwiftOperators
[259 / 386] SwiftOperators
[273 / 386] SwiftParserDiagnostics
[276 / 386] SwiftOperators
[280 / 386] SwiftOperators
[282 / 387] SwiftOperators
[283 / 387] SwiftSyntaxBuilder
[291 / 419]
[293 / 419]
[295 / 419]
[298 / 419]
[301 / 419]
[303 / 419]
[304 / 419]
[314 / 419] SwiftSyntaxBuilder
[315 / 419] SwiftSyntaxBuilder
[316 / 419] SwiftSyntaxBuilder
[324 / 421] SwiftSyntaxBuilder
[324 / 421] SwiftSyntaxMacros
[333 / 443] SwiftSyntaxSugar
[341 / 443] SwiftSyntaxMacros
[353 / 443] SwiftSyntaxSugar
[360 / 444] SwiftSyntaxMacros
[362 / 444] SwiftSyntaxMacroExpansion
[372 / 454] SwiftSyntaxMacroExpansion
[379 / 455] SwiftSyntaxMacroExpansion
[390 / 466] SwiftCompilerPluginMessageHandling
[391 / 466] SwiftCompilerPluginMessageHandling
[398 / 467] SwiftCompilerPluginMessageHandling
[399 / 467] SwiftCompilerPlugin
[402 / 469] SwiftCompilerPlugin
[408 / 469] SwiftSyntax
[410 / 469] SwiftSyntax
[416 / 469] SwiftSyntaxBuilder
[421 / 469] SwiftCompilerPlugin
[437 / 471] LockingMacros
[448 / 491] MockingMacros
[457 / 491] MockingMacros
[459 / 491] MockingMacros
[461 / 491] MockingMacros
[461 / 491] LockingMacros
[464 / 492] MockingMacros
[466 / 492] Locking
[469 / 495] Locking
[471 / 495] Locking
[480 / 496] Mocking
[491 / 507] Mocking
[503 / 508] MockingClient-product
[514 / 519] MockingClient-product
[517 / 519] MockingClient-product
Build complete! (33.21 sec)
Fetching https://github.com/swiftlang/swift-syntax.git
Fetching https://github.com/fetch-rewards/SwiftSyntaxSugar.git
Fetching https://github.com/fetch-rewards/swift-locking.git
[1/1908] Fetching swiftsyntaxsugar
[2/2639] Fetching swiftsyntaxsugar, swift-locking
[2640/82707] Fetching swiftsyntaxsugar, swift-locking, swift-syntax
Fetched https://github.com/swiftlang/swift-syntax.git (5.65s)
Fetched https://github.com/fetch-rewards/swift-locking.git (5.65s)
Fetched https://github.com/fetch-rewards/SwiftSyntaxSugar.git (5.65s)
Computing version for https://github.com/fetch-rewards/SwiftSyntaxSugar.git
Computed https://github.com/fetch-rewards/SwiftSyntaxSugar.git at 0.1.1 (6.25s)
Computing version for https://github.com/swiftlang/swift-syntax.git
Computed https://github.com/swiftlang/swift-syntax.git at 600.0.0 (2.86s)
Computing version for https://github.com/fetch-rewards/swift-locking.git
Computed https://github.com/fetch-rewards/swift-locking.git at 0.2.0 (0.55s)
Creating working copy for https://github.com/fetch-rewards/swift-locking.git
Working copy of https://github.com/fetch-rewards/swift-locking.git resolved at 0.2.0
Creating working copy for https://github.com/swiftlang/swift-syntax.git
Working copy of https://github.com/swiftlang/swift-syntax.git resolved at 600.0.0
Creating working copy for https://github.com/fetch-rewards/SwiftSyntaxSugar.git
Working copy of https://github.com/fetch-rewards/SwiftSyntaxSugar.git resolved at 0.1.1
macro expansion @_MockedMethod:7:32: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 1 | @MockedMembers
   | 2 | public final class AutoClosuresMock: AutoClosures {
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 5 |
   |   | 6 |     /// The implementation's closure type.
   |   | 7 |     public typealias Closure = (Void) -> Void
   |   |   |                                `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   | 8 |
   |   | 9 |     /// Does nothing when invoked.
   |   +----------------------------------------------------------------
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:21:37: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 1 | @MockedMembers
   | 2 | public final class AutoClosuresMock: AutoClosures {
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   |19 |     /// - Parameter closure: The closure to invoke.
   |   |20 |     public static func invokes(
   |   |21 |     	_ closure: @Sendable @escaping (Void) -> Void
   |   |   |                                     `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   |22 |     ) -> Self where Arguments: Sendable {
   |   |23 |         .uncheckedInvokes(closure)
   |   +----------------------------------------------------------------
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:7:32: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 5 |
   |   | 6 |     /// The implementation's closure type.
   |   | 7 |     public typealias Closure = (Void) async -> Void
   |   |   |                                `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   | 8 |
   |   | 9 |     /// Does nothing when invoked.
   |   +----------------------------------------------------------------
   | 6 |     public func methodWithNonVoidAsyncAutoClosure(
   | 7 |             autoClosure: @escaping @autoclosure () async -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:21:37: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   |19 |     /// - Parameter closure: The closure to invoke.
   |   |20 |     public static func invokes(
   |   |21 |     	_ closure: @Sendable @escaping (Void) async -> Void
   |   |   |                                     `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   |22 |     ) -> Self where Arguments: Sendable {
   |   |23 |         .uncheckedInvokes(closure)
   |   +----------------------------------------------------------------
   | 6 |     public func methodWithNonVoidAsyncAutoClosure(
   | 7 |             autoClosure: @escaping @autoclosure () async -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:7:32: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 9 |     public func methodWithVoidThrowingAutoClosure(
   |10 |             autoClosure: @escaping @autoclosure () throws -> Void
   |11 |         ) throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 5 |
   |   | 6 |     /// The implementation's closure type.
   |   | 7 |     public typealias Closure = (Void) throws -> Void
   |   |   |                                `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   | 8 |
   |   | 9 |     /// Does nothing when invoked.
   |   +----------------------------------------------------------------
   |12 |     public func methodWithNonVoidThrowingAutoClosure(
   |13 |             autoClosure: @escaping @autoclosure () throws -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:21:37: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 9 |     public func methodWithVoidThrowingAutoClosure(
   |10 |             autoClosure: @escaping @autoclosure () throws -> Void
   |11 |         ) throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   |19 |     /// - Parameter closure: The closure to invoke.
   |   |20 |     public static func invokes(
   |   |21 |     	_ closure: @Sendable @escaping (Void) throws -> Void
   |   |   |                                     `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   |22 |     ) -> Self where Arguments: Sendable {
   |   |23 |         .uncheckedInvokes(closure)
   |   +----------------------------------------------------------------
   |12 |     public func methodWithNonVoidThrowingAutoClosure(
   |13 |             autoClosure: @escaping @autoclosure () throws -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:7:32: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   |15 |     public func methodWithVoidAsyncThrowingAutoClosure(
   |16 |             autoClosure: @escaping @autoclosure () async throws -> Void
   |17 |         ) async throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 5 |
   |   | 6 |     /// The implementation's closure type.
   |   | 7 |     public typealias Closure = (Void) async throws -> Void
   |   |   |                                `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   | 8 |
   |   | 9 |     /// Does nothing when invoked.
   |   +----------------------------------------------------------------
   |18 |     public func methodWithNonVoidAsyncThrowingAutoClosure(
   |19 |             autoClosure: @escaping @autoclosure () async throws -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:21:37: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   |15 |     public func methodWithVoidAsyncThrowingAutoClosure(
   |16 |             autoClosure: @escaping @autoclosure () async throws -> Void
   |17 |         ) async throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   |19 |     /// - Parameter closure: The closure to invoke.
   |   |20 |     public static func invokes(
   |   |21 |     	_ closure: @Sendable @escaping (Void) async throws -> Void
   |   |   |                                     `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   |22 |     ) -> Self where Arguments: Sendable {
   |   |23 |         .uncheckedInvokes(closure)
   |   +----------------------------------------------------------------
   |18 |     public func methodWithNonVoidAsyncThrowingAutoClosure(
   |19 |             autoClosure: @escaping @autoclosure () async throws -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:2:9: warning: constant 'autoClosure' inferred to have type 'Void', which may be unexpected
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | |- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 1 | @MockedMembers
   | 2 | public final class AutoClosuresMock: AutoClosures {
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 1 | {
   |   | 2 |     let autoClosure = autoClosure()
   |   |   |         |- warning: constant 'autoClosure' inferred to have type 'Void', which may be unexpected
   |   |   |         `- note: add an explicit type annotation to silence this warning
   |   | 3 |     self.__methodWithVoidAutoClosure.recordInput(
   |   | 4 |         (
   |   +----------------------------------------------------------------
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:2:9: warning: constant 'autoClosure' inferred to have type 'Void', which may be unexpected
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | |- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 1 | {
   |   | 2 |     let autoClosure = await autoClosure()
   |   |   |         |- warning: constant 'autoClosure' inferred to have type 'Void', which may be unexpected
   |   |   |         `- note: add an explicit type annotation to silence this warning
   |   | 3 |     self.__methodWithVoidAsyncAutoClosure.recordInput(
   |   | 4 |         (
   |   +----------------------------------------------------------------
   | 6 |     public func methodWithNonVoidAsyncAutoClosure(
   | 7 |             autoClosure: @escaping @autoclosure () async -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:3:13: warning: constant 'autoClosure' inferred to have type 'Void', which may be unexpected
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | |- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 9 |     public func methodWithVoidThrowingAutoClosure(
   |10 |             autoClosure: @escaping @autoclosure () throws -> Void
   |11 |         ) throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 1 | {
   |   | 2 |     do {
   |   | 3 |         let autoClosure = try autoClosure()
   |   |   |             |- warning: constant 'autoClosure' inferred to have type 'Void', which may be unexpected
   |   |   |             `- note: add an explicit type annotation to silence this warning
   |   | 4 |         self.__methodWithVoidThrowingAutoClosure.recordInput(
   |   | 5 |             (
   |   +----------------------------------------------------------------
   |12 |     public func methodWithNonVoidThrowingAutoClosure(
   |13 |             autoClosure: @escaping @autoclosure () throws -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:3:13: warning: constant 'autoClosure' inferred to have type 'Void', which may be unexpected
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | |- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   |15 |     public func methodWithVoidAsyncThrowingAutoClosure(
   |16 |             autoClosure: @escaping @autoclosure () async throws -> Void
   |17 |         ) async throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 1 | {
   |   | 2 |     do {
   |   | 3 |         let autoClosure = try await autoClosure()
   |   |   |             |- warning: constant 'autoClosure' inferred to have type 'Void', which may be unexpected
   |   |   |             `- note: add an explicit type annotation to silence this warning
   |   | 4 |         self.__methodWithVoidAsyncThrowingAutoClosure.recordInput(
   |   | 5 |             (
   |   +----------------------------------------------------------------
   |18 |     public func methodWithNonVoidAsyncThrowingAutoClosure(
   |19 |             autoClosure: @escaping @autoclosure () async throws -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:7:32: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 1 | @MockedMembers
   | 2 | public final class AutoClosuresMock: AutoClosures {
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 5 |
   |   | 6 |     /// The implementation's closure type.
   |   | 7 |     public typealias Closure = (Void) -> Void
   |   |   |                                `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   | 8 |
   |   | 9 |     /// Does nothing when invoked.
   |   +----------------------------------------------------------------
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:21:37: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 1 | @MockedMembers
   | 2 | public final class AutoClosuresMock: AutoClosures {
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   |19 |     /// - Parameter closure: The closure to invoke.
   |   |20 |     public static func invokes(
   |   |21 |     	_ closure: @Sendable @escaping (Void) -> Void
   |   |   |                                     `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   |22 |     ) -> Self where Arguments: Sendable {
   |   |23 |         .uncheckedInvokes(closure)
   |   +----------------------------------------------------------------
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:7:32: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 5 |
   |   | 6 |     /// The implementation's closure type.
   |   | 7 |     public typealias Closure = (Void) async -> Void
   |   |   |                                `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   | 8 |
   |   | 9 |     /// Does nothing when invoked.
   |   +----------------------------------------------------------------
   | 6 |     public func methodWithNonVoidAsyncAutoClosure(
   | 7 |             autoClosure: @escaping @autoclosure () async -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:21:37: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 3 |     public func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   | 4 |     public func methodWithNonVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Int)
   | 5 |     public func methodWithVoidAsyncAutoClosure(autoClosure: @escaping @autoclosure () async -> Void) async
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   |19 |     /// - Parameter closure: The closure to invoke.
   |   |20 |     public static func invokes(
   |   |21 |     	_ closure: @Sendable @escaping (Void) async -> Void
   |   |   |                                     `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   |22 |     ) -> Self where Arguments: Sendable {
   |   |23 |         .uncheckedInvokes(closure)
   |   +----------------------------------------------------------------
   | 6 |     public func methodWithNonVoidAsyncAutoClosure(
   | 7 |             autoClosure: @escaping @autoclosure () async -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:7:32: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 9 |     public func methodWithVoidThrowingAutoClosure(
   |10 |             autoClosure: @escaping @autoclosure () throws -> Void
   |11 |         ) throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 5 |
   |   | 6 |     /// The implementation's closure type.
   |   | 7 |     public typealias Closure = (Void) throws -> Void
   |   |   |                                `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   | 8 |
   |   | 9 |     /// Does nothing when invoked.
   |   +----------------------------------------------------------------
   |12 |     public func methodWithNonVoidThrowingAutoClosure(
   |13 |             autoClosure: @escaping @autoclosure () throws -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:21:37: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   | 9 |     public func methodWithVoidThrowingAutoClosure(
   |10 |             autoClosure: @escaping @autoclosure () throws -> Void
   |11 |         ) throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   |19 |     /// - Parameter closure: The closure to invoke.
   |   |20 |     public static func invokes(
   |   |21 |     	_ closure: @Sendable @escaping (Void) throws -> Void
   |   |   |                                     `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   |22 |     ) -> Self where Arguments: Sendable {
   |   |23 |         .uncheckedInvokes(closure)
   |   +----------------------------------------------------------------
   |12 |     public func methodWithNonVoidThrowingAutoClosure(
   |13 |             autoClosure: @escaping @autoclosure () throws -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:7:32: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   |15 |     public func methodWithVoidAsyncThrowingAutoClosure(
   |16 |             autoClosure: @escaping @autoclosure () async throws -> Void
   |17 |         ) async throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   | 5 |
   |   | 6 |     /// The implementation's closure type.
   |   | 7 |     public typealias Closure = (Void) async throws -> Void
   |   |   |                                `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   | 8 |
   |   | 9 |     /// Does nothing when invoked.
   |   +----------------------------------------------------------------
   |18 |     public func methodWithNonVoidAsyncThrowingAutoClosure(
   |19 |             autoClosure: @escaping @autoclosure () async throws -> Int
   +--------------------------------------------------------------------
36 |
macro expansion @_MockedMethod:21:37: warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
`- /Users/admin/builder/spi-builder-workspace/Sources/MockingClient/AutoClosures.swift:35:2: note: expanded code originates here
13 | ///   Mocked's handling of autoclosures. For temporary testing of Mocked's
14 | ///   expansion, use the `Playground` protocol in `main.swift`.
15 | @Mocked(compilationCondition: .none)
   | `- note: in expansion of macro 'Mocked' on protocol 'AutoClosures' here
16 | public protocol AutoClosures {
17 |     func methodWithVoidAutoClosure(autoClosure: @escaping @autoclosure () -> Void)
   :
33 |         autoClosure: @escaping @autoclosure () async throws -> Int
34 |     ) async throws
35 | }
   +--- macro expansion @Mocked ----------------------------------------
   |15 |     public func methodWithVoidAsyncThrowingAutoClosure(
   |16 |             autoClosure: @escaping @autoclosure () async throws -> Void
   |17 |         ) async throws
   |   +--- macro expansion @_MockedMethod -----------------------------
   |   |19 |     /// - Parameter closure: The closure to invoke.
   |   |20 |     public static func invokes(
   |   |21 |     	_ closure: @Sendable @escaping (Void) async throws -> Void
   |   |   |                                     `- warning: when calling this function in Swift 4 or later, you must pass a '()' tuple; did you mean for the input type to be '()'?
   |   |22 |     ) -> Self where Arguments: Sendable {
   |   |23 |         .uncheckedInvokes(closure)
   |   +----------------------------------------------------------------
   |18 |     public func methodWithNonVoidAsyncThrowingAutoClosure(
   |19 |             autoClosure: @escaping @autoclosure () async throws -> Int
   +--------------------------------------------------------------------
36 |
Build complete.
{
  "dependencies" : [
    {
      "identity" : "swift-locking",
      "requirement" : {
        "exact" : [
          "0.2.0"
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/fetch-rewards/swift-locking.git"
    },
    {
      "identity" : "swift-syntax",
      "requirement" : {
        "exact" : [
          "600.0.0"
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/swiftlang/swift-syntax.git"
    },
    {
      "identity" : "swiftsyntaxsugar",
      "requirement" : {
        "exact" : [
          "0.1.1"
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/fetch-rewards/SwiftSyntaxSugar.git"
    }
  ],
  "manifest_display_name" : "swift-mocking",
  "name" : "swift-mocking",
  "path" : "/Users/admin/builder/spi-builder-workspace",
  "platforms" : [
    {
      "name" : "macos",
      "version" : "13.0"
    },
    {
      "name" : "ios",
      "version" : "16.0"
    },
    {
      "name" : "tvos",
      "version" : "16.0"
    },
    {
      "name" : "watchos",
      "version" : "9.0"
    },
    {
      "name" : "maccatalyst",
      "version" : "16.0"
    }
  ],
  "products" : [
    {
      "name" : "Mocking",
      "targets" : [
        "Mocking"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "MockingClient",
      "targets" : [
        "MockingClient"
      ],
      "type" : {
        "executable" : null
      }
    },
    {
      "name" : "MockingMacros",
      "targets" : [
        "MockingMacros"
      ],
      "type" : {
        "macro" : null
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "MockingTests",
      "module_type" : "SwiftTarget",
      "name" : "MockingTests",
      "path" : "Tests/MockingTests",
      "sources" : [
        "Models/MacroArguments/MockedPropertyType/MockedPropertyTypeTests.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptTypeTests.swift",
        "Models/MockImplementationDescription/MockImplementationDescriptionTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedAsyncMethod/MockReturningNonParameterizedAsyncMethodTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedAsyncMethod/MockReturningNonParameterizedAsyncMethod_ImplementationTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedAsyncThrowingMethod/MockReturningNonParameterizedAsyncThrowingMethodTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedAsyncThrowingMethod/MockReturningNonParameterizedAsyncThrowingMethod_ImplementationTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedMethod/MockReturningNonParameterizedMethodTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedMethod/MockReturningNonParameterizedMethod_ImplementationTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedThrowingMethod/MockReturningNonParameterizedThrowingMethodTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedThrowingMethod/MockReturningNonParameterizedThrowingMethod_ImplementationTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedAsyncMethod/MockReturningParameterizedAsyncMethodTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedAsyncThrowingMethod/MockReturningParameterizedAsyncThrowingMethodTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedMethod/MockReturningParameterizedMethodTests.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedThrowingMethod/MockReturningParameterizedThrowingMethodTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedAsyncMethod/MockVoidNonParameterizedAsyncMethodTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedAsyncMethod/MockVoidNonParameterizedAsyncMethod_ImplementationTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedAsyncThrowingMethod/MockVoidNonParameterizedAsyncThrowingMethodTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedAsyncThrowingMethod/MockVoidNonParameterizedAsyncThrowingMethod_ImplementationTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedMethod/MockVoidNonParameterizedMethodTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedMethod/MockVoidNonParameterizedMethod_ImplementationTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedThrowingMethod/MockVoidNonParameterizedThrowingMethodTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedThrowingMethod/MockVoidNonParameterizedThrowingMethod_ImplementationTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedAsyncMethod/MockVoidParameterizedAsyncMethodTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedAsyncThrowingMethod/MockVoidParameterizedAsyncThrowingMethodTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedMethod/MockVoidParameterizedMethodTests.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedThrowingMethod/MockVoidParameterizedThrowingMethodTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertyAsyncGetter/MockPropertyAsyncGetterTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertyAsyncGetter/MockPropertyAsyncGetter_ImplementationTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertyAsyncThrowingGetter/MockPropertyAsyncThrowingGetterTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertyAsyncThrowingGetter/MockPropertyAsyncThrowingGetter_ImplementationTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertyGetter/MockPropertyGetterTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertyGetter/MockPropertyGetter_ImplementationTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertySetter/MockPropertySetterTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertySetter/MockPropertySetter_ImplementationTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertyThrowingGetter/MockPropertyThrowingGetterTests.swift",
        "Models/MockProperties/MockAccessors/MockPropertyThrowingGetter/MockPropertyThrowingGetter_ImplementationTests.swift",
        "Models/MockSubscripts/MockReadOnlyAsyncSubscriptTests.swift",
        "Models/MockSubscripts/MockReadOnlyAsyncThrowingSubscriptTests.swift",
        "Models/MockSubscripts/MockReadOnlySubscriptTests.swift",
        "Models/MockSubscripts/MockReadOnlyThrowingSubscriptTests.swift",
        "Models/MockSubscripts/MockReadWriteSubscriptTests.swift",
        "Models/MockSubscripts/MockSubscriptAsyncGetter/MockSubscriptAsyncGetterTests.swift",
        "Models/MockSubscripts/MockSubscriptAsyncGetter/MockSubscriptAsyncGetter_ImplementationTests.swift",
        "Models/MockSubscripts/MockSubscriptAsyncThrowingGetter/MockSubscriptAsyncThrowingGetterTests.swift",
        "Models/MockSubscripts/MockSubscriptAsyncThrowingGetter/MockSubscriptAsyncThrowingGetter_ImplementationTests.swift",
        "Models/MockSubscripts/MockSubscriptGetter/MockSubscriptGetterTests.swift",
        "Models/MockSubscripts/MockSubscriptGetter/MockSubscriptGetter_ImplementationTests.swift",
        "Models/MockSubscripts/MockSubscriptSetter/MockSubscriptSetterTests.swift",
        "Models/MockSubscripts/MockSubscriptSetter/MockSubscriptSetter_ImplementationTests.swift",
        "Models/MockSubscripts/MockSubscriptThrowingGetter/MockSubscriptThrowingGetterTests.swift",
        "Models/MockSubscripts/MockSubscriptThrowingGetter/MockSubscriptThrowingGetter_ImplementationTests.swift",
        "TestHelpers/TestBarrier.swift"
      ],
      "target_dependencies" : [
        "Mocking"
      ],
      "type" : "test"
    },
    {
      "c99name" : "MockingMacrosTests",
      "module_type" : "SwiftTarget",
      "name" : "MockingMacrosTests",
      "path" : "Tests/MockingMacrosTests",
      "product_dependencies" : [
        "SwiftSyntaxMacrosTestSupport"
      ],
      "sources" : [
        "Macros/MockableSubscriptMacro/MockableSubscript_ReadOnlySubscriptTests.swift",
        "Macros/MockableSubscriptMacro/MockableSubscript_ReadWriteSubscriptTests.swift",
        "Macros/MockableSubscriptMacro/TestHelpers/AssertMockableSubscript.swift",
        "Macros/MockedMacro/MockedMacro_MacroErrorTests.swift",
        "Macros/MockedMacro/Mocked_AccessLevelTests.swift",
        "Macros/MockedMacro/Mocked_AssociatedTypeTests.swift",
        "Macros/MockedMacro/Mocked_CompilationConditionTests.swift",
        "Macros/MockedMacro/Mocked_IfConfigDeclarationTests.swift",
        "Macros/MockedMacro/Mocked_InheritanceTests.swift",
        "Macros/MockedMacro/Mocked_InitializerTests.swift",
        "Macros/MockedMacro/Mocked_MacroArgumentsTests.swift",
        "Macros/MockedMacro/Mocked_SendableConformanceTests.swift",
        "Macros/MockedMacro/Mocked_SubscriptTests.swift",
        "Macros/MockedMacro/TestHelpers/AssertMocked.swift",
        "Macros/MockedMacro/TestHelpers/InterfaceConfiguration.swift",
        "Macros/MockedMacro/TestHelpers/MockConfiguration.swift",
        "Macros/MockedMacro/TestHelpers/MockedTestConfigurations.swift",
        "Macros/MockedMembersMacro/MockedMembers_InitializerTests.swift",
        "Macros/MockedMembersMacro/MockedMembers_MethodOverloadsTests.swift",
        "Macros/MockedMembersMacro/MockedMembers_SubscriptOverloadsTests.swift",
        "Macros/MockedMembersMacro/TestHelpers/AssertMockedMembers.swift",
        "Macros/MockedMethodMacro/MockedMethod_AttributedClosureTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_AutoClosureTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_ArrayTypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_AttributedTypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_DictionaryTypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_FunctionTypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_IdentifierTypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_MemberTypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_MetatypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_OpaqueTypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_OptionalTypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_GenericMethod_TupleTypeTests.swift",
        "Macros/MockedMethodMacro/MockedMethod_VariadicParameterTests.swift",
        "Macros/MockedMethodMacro/TestHelpers/AssertMockedMethod.swift",
        "Macros/MockedPropertyMacro/MockedProperty_ReadOnlyPropertyTests.swift",
        "Macros/MockedPropertyMacro/MockedProperty_ReadWritePropertyTests.swift",
        "Macros/MockedPropertyMacro/TestHelpers/AssertMockedProperty.swift",
        "Macros/MockedSubscriptMacro/MockedSubscriptMacro_ExpansionErrorTests.swift",
        "Macros/MockedSubscriptMacro/MockedSubscriptMacro_MacroErrorTests.swift",
        "Macros/MockedSubscriptMacro/MockedSubscript_ActorTests.swift",
        "Macros/MockedSubscriptMacro/MockedSubscript_GenericSubscriptTests.swift",
        "Macros/MockedSubscriptMacro/MockedSubscript_MultiParameterTests.swift",
        "Macros/MockedSubscriptMacro/MockedSubscript_ReadOnlySubscriptTests.swift",
        "Macros/MockedSubscriptMacro/MockedSubscript_ReadWriteSubscriptTests.swift",
        "Macros/MockedSubscriptMacro/TestHelpers/AssertMockedSubscript.swift",
        "Models/MacroArguments/MockCompilationCondition/MockCompilationConditionTests.swift",
        "Models/MacroArguments/MockCompilationCondition/MockCompilationCondition_ParsingErrorTests.swift",
        "Models/MacroArguments/MockSendableConformance/MockSendableConformanceTests.swift",
        "Models/MacroArguments/MockSendableConformance/MockSendableConformance_ParsingErrorTests.swift",
        "Models/MacroArguments/MockedPropertyType/MockedPropertyTypeTests.swift",
        "Models/MacroArguments/MockedPropertyType/MockedPropertyType_ParsingErrorTests.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptTypeTests.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptType_ParsingErrorTests.swift",
        "Models/MockMemberNameComponents/MockMemberNameComponentsTests.swift",
        "TestHelpers/Extensions/LabeledExprSyntax+MacroArgumentSyntax.swift"
      ],
      "target_dependencies" : [
        "MockingMacros"
      ],
      "type" : "test"
    },
    {
      "c99name" : "MockingMacros",
      "module_type" : "SwiftTarget",
      "name" : "MockingMacros",
      "path" : "Sources/MockingMacros",
      "product_dependencies" : [
        "SwiftCompilerPlugin",
        "SwiftSyntaxMacros",
        "SwiftSyntaxSugar"
      ],
      "product_memberships" : [
        "Mocking",
        "MockingClient",
        "MockingMacros"
      ],
      "sources" : [
        "Extensions/InheritedTypeSyntax/InheritedTypeSyntax+UncheckedSendable.swift",
        "Extensions/String/String+WithFirstCharacterCapitalized.swift",
        "Macros/MockableMethodMacro/MockableMethodMacro.swift",
        "Macros/MockablePropertyMacro/MockablePropertyMacro.swift",
        "Macros/MockableSubscriptMacro/MockableSubscriptMacro.swift",
        "Macros/MockedMacro/MockedMacro+MacroArguments.swift",
        "Macros/MockedMacro/MockedMacro+MacroError.swift",
        "Macros/MockedMacro/MockedMacro.swift",
        "Macros/MockedMembersMacro/MockedMembersMacro+MacroError.swift",
        "Macros/MockedMembersMacro/MockedMembersMacro+MemberAttributeMacro.swift",
        "Macros/MockedMembersMacro/MockedMembersMacro+MemberMacro.swift",
        "Macros/MockedMembersMacro/MockedMembersMacro.swift",
        "Macros/MockedMethodMacro/MockedMethodMacro+BodyMacro.swift",
        "Macros/MockedMethodMacro/MockedMethodMacro+MacroArguments.swift",
        "Macros/MockedMethodMacro/MockedMethodMacro+MacroError.swift",
        "Macros/MockedMethodMacro/MockedMethodMacro+PeerMacro.swift",
        "Macros/MockedMethodMacro/MockedMethodMacro+TypeErasure.swift",
        "Macros/MockedMethodMacro/MockedMethodMacro.swift",
        "Macros/MockedPropertyMacro/MockedPropertyMacro+AccessorMacro.swift",
        "Macros/MockedPropertyMacro/MockedPropertyMacro+MacroArguments.swift",
        "Macros/MockedPropertyMacro/MockedPropertyMacro+MacroError.swift",
        "Macros/MockedPropertyMacro/MockedPropertyMacro+PeerMacro.swift",
        "Macros/MockedPropertyMacro/MockedPropertyMacro.swift",
        "Macros/MockedSubscriptMacro/MockedSubscriptMacro+AccessorMacro.swift",
        "Macros/MockedSubscriptMacro/MockedSubscriptMacro+MacroArguments.swift",
        "Macros/MockedSubscriptMacro/MockedSubscriptMacro+MacroError.swift",
        "Macros/MockedSubscriptMacro/MockedSubscriptMacro+PeerMacro.swift",
        "Macros/MockedSubscriptMacro/MockedSubscriptMacro.swift",
        "MockingPlugin.swift",
        "Models/MacroArguments/MacroArgumentValue.swift",
        "Models/MacroArguments/MockCompilationCondition/MockCompilationCondition+ParsingError.swift",
        "Models/MacroArguments/MockCompilationCondition/MockCompilationCondition.swift",
        "Models/MacroArguments/MockSendableConformance/MockSendableConformance+ParsingError.swift",
        "Models/MacroArguments/MockSendableConformance/MockSendableConformance.swift",
        "Models/MacroArguments/MockedPropertyType/MockedPropertyType+AsyncSpecifier.swift",
        "Models/MacroArguments/MockedPropertyType/MockedPropertyType+ParsingError.swift",
        "Models/MacroArguments/MockedPropertyType/MockedPropertyType+ThrowsSpecifier.swift",
        "Models/MacroArguments/MockedPropertyType/MockedPropertyType.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptType+AsyncSpecifier.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptType+ParsingError.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptType+ThrowsSpecifier.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptType.swift",
        "Models/MockMemberNameComponents/MockMemberNameComponents.swift",
        "Models/MockMemberNameComponents/MockMethodNameComponent+ID.swift",
        "Models/MockMemberNameComponents/MockMethodNameComponent.swift"
      ],
      "type" : "macro"
    },
    {
      "c99name" : "MockingClient",
      "module_type" : "SwiftTarget",
      "name" : "MockingClient",
      "path" : "Sources/MockingClient",
      "product_memberships" : [
        "MockingClient"
      ],
      "sources" : [
        "AttributedClosures.swift",
        "AttributedTypes.swift",
        "AutoClosures.swift",
        "CompilationConditions.swift",
        "GenericMethodsWithArrayTypes.swift",
        "GenericMethodsWithAttributedTypes.swift",
        "GenericMethodsWithDictionaryTypes.swift",
        "GenericMethodsWithFunctionTypes.swift",
        "GenericMethodsWithIdentifierTypes.swift",
        "GenericMethodsWithMemberTypes.swift",
        "GenericMethodsWithMetatypes.swift",
        "GenericMethodsWithOpaqueTypes.swift",
        "GenericMethodsWithOptionalTypes.swift",
        "GenericMethodsWithTupleTypes.swift",
        "Initializers.swift",
        "MethodOverloads.swift",
        "NonParameterizedMethods.swift",
        "ParameterizedMethods.swift",
        "SendableSubscripts.swift",
        "StaticMembers.swift",
        "Subscripts.swift",
        "VariadicParameters.swift",
        "main.swift"
      ],
      "target_dependencies" : [
        "Mocking"
      ],
      "type" : "executable"
    },
    {
      "c99name" : "Mocking",
      "module_type" : "SwiftTarget",
      "name" : "Mocking",
      "path" : "Sources/Mocking",
      "product_dependencies" : [
        "Locking"
      ],
      "product_memberships" : [
        "Mocking",
        "MockingClient"
      ],
      "sources" : [
        "Extensions/Result+AsyncCatching.swift",
        "Macros/MockableMethod.swift",
        "Macros/MockableProperty.swift",
        "Macros/MockableSubscript.swift",
        "Macros/Mocked.swift",
        "Macros/MockedMembers.swift",
        "Macros/MockedMethod.swift",
        "Macros/MockedProperty.swift",
        "Macros/MockedSubscript.swift",
        "Models/MacroArguments/MockCompilationCondition.swift",
        "Models/MacroArguments/MockSendableConformance.swift",
        "Models/MacroArguments/MockedPropertyType/MockedPropertyType+AsyncSpecifier.swift",
        "Models/MacroArguments/MockedPropertyType/MockedPropertyType+ThrowsSpecifier.swift",
        "Models/MacroArguments/MockedPropertyType/MockedPropertyType.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptType+AsyncSpecifier.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptType+ThrowsSpecifier.swift",
        "Models/MacroArguments/MockedSubscriptType/MockedSubscriptType.swift",
        "Models/MockImplementationDescription/MockImplementationDescription.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningMethodImplementation.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedAsyncMethod/MockReturningNonParameterizedAsyncMethod+Implementation.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedAsyncMethod/MockReturningNonParameterizedAsyncMethod.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedAsyncThrowingMethod/MockReturningNonParameterizedAsyncThrowingMethod+Implementation.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedAsyncThrowingMethod/MockReturningNonParameterizedAsyncThrowingMethod.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedMethod/MockReturningNonParameterizedMethod+Implementation.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedMethod/MockReturningNonParameterizedMethod.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedThrowingMethod/MockReturningNonParameterizedThrowingMethod+Implementation.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningNonParameterizedThrowingMethod/MockReturningNonParameterizedThrowingMethod.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedAsyncMethod/MockReturningParameterizedAsyncMethod.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedAsyncMethod/MockReturningParameterizedAsyncMethodImplementation.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedAsyncThrowingMethod/MockReturningParameterizedAsyncThrowingMethod.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedAsyncThrowingMethod/MockReturningParameterizedAsyncThrowingMethodImplementation.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedMethod/MockReturningParameterizedMethod.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedMethod/MockReturningParameterizedMethodImplementation.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedThrowingMethod/MockReturningParameterizedThrowingMethod.swift",
        "Models/MockMethods/MockReturningMethods/MockReturningParameterizedThrowingMethod/MockReturningParameterizedThrowingMethodImplementation.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidMethodImplementation.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedAsyncMethod/MockVoidNonParameterizedAsyncMethod+Implementation.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedAsyncMethod/MockVoidNonParameterizedAsyncMethod.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedAsyncThrowingMethod/MockVoidNonParameterizedAsyncThrowingMethod+Implementation.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedAsyncThrowingMethod/MockVoidNonParameterizedAsyncThrowingMethod.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedMethod/MockVoidNonParameterizedMethod+Implementation.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedMethod/MockVoidNonParameterizedMethod.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedThrowingMethod/MockVoidNonParameterizedThrowingMethod+Implementation.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidNonParameterizedThrowingMethod/MockVoidNonParameterizedThrowingMethod.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedAsyncMethod/MockVoidParameterizedAsyncMethod.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedAsyncMethod/MockVoidParameterizedAsyncMethodImplementation.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedAsyncThrowingMethod/MockVoidParameterizedAsyncThrowingMethod.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedAsyncThrowingMethod/MockVoidParameterizedAsyncThrowingMethodImplementation.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedMethod/MockVoidParameterizedMethod.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedMethod/MockVoidParameterizedMethodImplementation.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedThrowingMethod/MockVoidParameterizedThrowingMethod.swift",
        "Models/MockMethods/MockVoidMethods/MockVoidParameterizedThrowingMethod/MockVoidParameterizedThrowingMethodImplementation.swift",
        "Models/MockProperties/MockAccessors/MockPropertyAsyncGetter/MockPropertyAsyncGetter+Implementation.swift",
        "Models/MockProperties/MockAccessors/MockPropertyAsyncGetter/MockPropertyAsyncGetter.swift",
        "Models/MockProperties/MockAccessors/MockPropertyAsyncThrowingGetter/MockPropertyAsyncThrowingGetter+Implementation.swift",
        "Models/MockProperties/MockAccessors/MockPropertyAsyncThrowingGetter/MockPropertyAsyncThrowingGetter.swift",
        "Models/MockProperties/MockAccessors/MockPropertyGetter/MockPropertyGetter+Implementation.swift",
        "Models/MockProperties/MockAccessors/MockPropertyGetter/MockPropertyGetter.swift",
        "Models/MockProperties/MockAccessors/MockPropertySetter/MockPropertySetter+Implementation.swift",
        "Models/MockProperties/MockAccessors/MockPropertySetter/MockPropertySetter.swift",
        "Models/MockProperties/MockAccessors/MockPropertyThrowingGetter/MockPropertyThrowingGetter+Implementation.swift",
        "Models/MockProperties/MockAccessors/MockPropertyThrowingGetter/MockPropertyThrowingGetter.swift",
        "Models/MockProperties/MockReadOnlyAsyncProperty.swift",
        "Models/MockProperties/MockReadOnlyAsyncThrowingProperty.swift",
        "Models/MockProperties/MockReadOnlyProperty.swift",
        "Models/MockProperties/MockReadOnlyThrowingProperty.swift",
        "Models/MockProperties/MockReadWriteProperty.swift",
        "Models/MockSubscripts/MockReadOnlyAsyncSubscript.swift",
        "Models/MockSubscripts/MockReadOnlyAsyncThrowingSubscript.swift",
        "Models/MockSubscripts/MockReadOnlySubscript.swift",
        "Models/MockSubscripts/MockReadOnlyThrowingSubscript.swift",
        "Models/MockSubscripts/MockReadWriteSubscript.swift",
        "Models/MockSubscripts/MockSubscriptAsyncGetter/MockSubscriptAsyncGetter+Implementation.swift",
        "Models/MockSubscripts/MockSubscriptAsyncGetter/MockSubscriptAsyncGetter.swift",
        "Models/MockSubscripts/MockSubscriptAsyncThrowingGetter/MockSubscriptAsyncThrowingGetter+Implementation.swift",
        "Models/MockSubscripts/MockSubscriptAsyncThrowingGetter/MockSubscriptAsyncThrowingGetter.swift",
        "Models/MockSubscripts/MockSubscriptGetter/MockSubscriptGetter+Implementation.swift",
        "Models/MockSubscripts/MockSubscriptGetter/MockSubscriptGetter.swift",
        "Models/MockSubscripts/MockSubscriptSetter/MockSubscriptSetter+Implementation.swift",
        "Models/MockSubscripts/MockSubscriptSetter/MockSubscriptSetter.swift",
        "Models/MockSubscripts/MockSubscriptThrowingGetter/MockSubscriptThrowingGetter+Implementation.swift",
        "Models/MockSubscripts/MockSubscriptThrowingGetter/MockSubscriptThrowingGetter.swift"
      ],
      "target_dependencies" : [
        "MockingMacros"
      ],
      "type" : "library"
    }
  ],
  "tools_version" : "6.0"
}
Done.