Concurrency safe handler

[sidepelican]

Issue: #249

When the mock protocol requires Sendable, correctly implement the mock functions as Sendable. To provide a concurrency-safe implementation, we also add some helper functions and types.

This PR does not address stored properties or computed properties (Do it later).

As shown below, various function Handlers are required to be Sendable.

/// @mockable
protocol APIClient: Sendable {
    func fetchData(_ id: AnyObject) async -> Int
}

final class APIClientMock: APIClient {
    init() { }

    private let fetchDataState = MockoloMutex(MockoloHandlerState<AnyObject, @Sendable (AnyObject) async -> Int>())
    var fetchDataCallCount: Int {
        return fetchDataState.withLock(\.callCount)
    }
    var fetchDataArgValues: [AnyObject] {
        return fetchDataState.withLock(\.argValues).map(\.value)
    }
    var fetchDataHandler: (@Sendable (AnyObject) async -> (Int))? {
        get { fetchDataState.withLock(\.handler) }
        set { fetchDataState.withLock { $0.handler = newValue } }
    }
    func fetchData(_ id: AnyObject) async -> Int {
        warnIfNotSendable(id)
        let handler = fetchDataState.withLock { state in
            state.callCount += 1
            state.argValues.append(.init(id))
            return state.handler
        }
        if let handler {
            return await handler(id)
        }
        return 0
    }
}

[sidepelican]

I changed the implementation because the processing became more complex.

[sidepelican]

Instead of examining all lines, we check whether the output lines contain the fixture.

[fummicc1]

Thank you so much! LGTM from my side, but I left some questions for posterity.

[fummicc1]

[question]

I am sorry but could you elaborate why you delete inheritedTypes?

[sidepelican]

Because it is never used.
It might be back in the future if needed.

[fummicc1]

I am not confident this print statement is needed or not, as mocking library.
I think print is not time-efficient. It might be good to opt-in this warning in another PR. What do you think of it?

[sidepelican]

This function is called only if there is an issue with the user's implementation, so it can be resolved if the user fixes the problem.

As an escape hatch, I want to make it possible to disable it with:

/// @mockable(history: fooFunc = false)

(Probably it cannot be done now.)

[fummicc1]

[question]

Actor protocol is not written here. Is it okay?

[sidepelican]

The mock of an Actor protocol automatically becomes an actor, so it is not necessary to make the mock implementation Sendable.