Improve support Swift Concurrency - fix support detect MainActor register with modificators.

Author: ivlevAstef

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 5.0.2
+* Improve support Swift Concurrency - fix support detect MainActor register with modificators. e.g.:
+`container.register(MyMainActorClass.init) { arg($0) }`
+
 # 5.0.1
 * Improve support Swift Concurrency - fix support detect MainActor classes for register methods initialize.
 

Sources/Core/API/AutoResolve/DIContainer.RegModify.swift

@@ -38,4 +38,36 @@ extension DIContainer {
                                                 modificator: @escaping (M0, M1) -> (P0, P1)) -> DIComponentBuilder<Impl> {
     return register(file, line, MethodMaker.eachMake(by: closure, modificator: modificator))
   }
+
+  /// Declaring a new component with initial and modificator one argument.
+  /// Using:
+  /// ```
+  /// container.register(YourClass.init) { arg($0) }
+  /// ```
+  ///
+  /// - Parameter closure: initial method. Must return type declared at registration.
+  /// - Parameter modificator: Need for support set arg / many / tag on first initial argument.
+  /// - Returns: component builder, to configure the component.
+  @discardableResult
+  public func register<Impl,P0,each P,M0>(file: String = #file, line: Int = #line,
+                                          _ closure: @escaping @MainActor (P0, repeat each P) -> Impl,
+                                          modificator: @escaping (M0) -> P0) -> DIComponentBuilder<Impl> where Impl: Sendable {
+        return register(file, line, MethodMaker.eachMakeMainActor(by: closure, modificator: modificator))
+    }
+
+    /// Declaring a new component with initial and modificator one argument.
+    /// Using:
+    /// ```
+    /// container.register(YourClass.init) { (arg($0), many($1)) }
+    /// ```
+    ///
+    /// - Parameter closure: initial method. Must return type declared at registration.
+    /// - Parameter modificator: Need for support set arg / many / tag on first and second initial argument.
+    /// - Returns: component builder, to configure the component.
+    @discardableResult
+    public func register<Impl,P0,P1,each P,M0,M1>(file: String = #file, line: Int = #line,
+                                                  _ closure: @escaping @MainActor (P0, P1, repeat each P) -> Impl,
+                                                  modificator: @escaping (M0, M1) -> (P0, P1)) -> DIComponentBuilder<Impl> where Impl: Sendable {
+        return register(file, line, MethodMaker.eachMakeMainActor(by: closure, modificator: modificator))
+    }
 }

Sources/Core/Internal/MethodMaker.swift

@@ -115,4 +115,55 @@ extension MethodMaker {
       }
     }
   }
+
+  static func eachMakeMainActor<P0, each P, M0, R>(
+      by f: @escaping @MainActor (P0, repeat each P) -> R,
+      modificator: @escaping (M0) -> P0) -> MethodSignature where R: Sendable
+  {
+    let types = EachTypes()
+    types.append(M0.self)
+    repeat types.append((each P).self)
+
+    return MethodSignature(types.result, nil) { params in
+      let maker = EachMaker(params: params)
+      let modifyResult = modificator(maker.make())
+      if Thread.isMainThread {
+        return MainActor.assumeIsolated {
+          f(modifyResult, repeat maker.make() as each P)
+        }
+      } else {
+        return DispatchQueue.main.sync {
+          MainActor.assumeIsolated {
+            f(modifyResult, repeat maker.make() as each P)
+          }
+        }
+      }
+    }
+  }
+
+  static func eachMakeMainActor<P0, P1, each P, M0, M1, R>(
+      by f: @escaping @MainActor (P0, P1, repeat each P) -> R,
+      modificator: @escaping (M0, M1) -> (P0, P1)) -> MethodSignature where R: Sendable
+  {
+    let types = EachTypes()
+    types.append(M0.self)
+    types.append(M1.self)
+    repeat types.append((each P).self)
+
+    return MethodSignature(types.result, nil) { params in
+      let maker = EachMaker(params: params)
+      let modifyResult = modificator(maker.make(), maker.make())
+      if Thread.isMainThread {
+        return MainActor.assumeIsolated {
+          return f(modifyResult.0, modifyResult.1, repeat maker.make() as each P)
+        }
+      } else {
+        return DispatchQueue.main.sync {
+          MainActor.assumeIsolated {
+            return f(modifyResult.0, modifyResult.1, repeat maker.make() as each P)
+          }
+        }
+      }
+    }
+  }
 }

Tests/DITranquillityTests_ResolveByInit.swift

@@ -33,6 +33,34 @@ private final class TestMainActor {
   }
 }
 
+@MainActor
+private final class TestMainActorArgument {
+    let str: String = "bar"
+    let arg: Int
+    let other: TestOtherMainActor
+    init(arg: Int, other: TestOtherMainActor) {
+        self.arg = arg
+        self.other = other
+        assert(Thread.isMainThread)
+        MainActor.assertIsolated()
+    }
+}
+
+@MainActor
+private final class TestMainActorArgument2 {
+    let str: String = "bar"
+    let arg1: Int
+    let arg2: String
+    let other: TestOtherMainActor
+    init(arg1: Int, arg2: String, other: TestOtherMainActor) {
+        self.arg1 = arg1
+        self.arg2 = arg2
+        self.other = other
+        assert(Thread.isMainThread)
+        MainActor.assertIsolated()
+    }
+}
+
 private final class TestActorClassInjected: Sendable {
 }
 
@@ -107,35 +135,53 @@ class DITranquillityTests_ResolveByInit: XCTestCase {
 
     container.register(TestOtherMainActor.init)
     container.register(TestMainActor.init)
+    container.register(TestMainActorArgument.init) { arg($0) }
+    container.register(TestMainActorArgument2.init) { (arg($0), arg($1)) }
 
     let m1: TestOtherMainActor = container.resolve()
     let m2: TestMainActor = container.resolve()
+    let m3: TestMainActorArgument = container.resolve(args: 10)
+    let m4: TestMainActorArgument2 = container.resolve(args: 100, "a100")
 
     XCTAssert(m1.str == "foo")
     XCTAssert(m2.str == "bar")
+    XCTAssert(m3.arg == 10)
+    XCTAssert(m4.arg1 == 100 && m4.arg2 == "a100")
 
     DispatchQueue.global(qos: DispatchQoS.QoSClass.userInteractive).async {
-      let m1InThread: TestOtherMainActor = container.resolve()
-      let m2InThread: TestMainActor = container.resolve()
+      let m1: TestOtherMainActor = container.resolve()
+      let m2: TestMainActor = container.resolve()
+      let m3: TestMainActorArgument = container.resolve(args: 20)
+      let m4: TestMainActorArgument2 = container.resolve(args: 200, "a200")
 
-      XCTAssert(m1InThread.str == "foo")
-      XCTAssert(m2InThread.str == "bar")
+      XCTAssert(m1.str == "foo")
+      XCTAssert(m2.str == "bar")
+      XCTAssert(m3.arg == 20)
+      XCTAssert(m4.arg1 == 200 && m4.arg2 == "a200")
     }
 
     Task { @MainActor in
       let m1: TestOtherMainActor = container.resolve()
       let m2: TestMainActor = container.resolve()
+      let m3: TestMainActorArgument = container.resolve(args: 30)
+      let m4: TestMainActorArgument2 = container.resolve(args: 300, "a300")
 
       XCTAssert(m1.str == "foo")
       XCTAssert(m2.str == "bar")
+      XCTAssert(m3.arg == 30)
+      XCTAssert(m4.arg1 == 300 && m4.arg2 == "a300")
     }
 
     Task { @MyGlobalActor in
       let m1: TestOtherMainActor = container.resolve()
       let m2: TestMainActor = container.resolve()
+      let m3: TestMainActorArgument = container.resolve(args: 40)
+      let m4: TestMainActorArgument2 = container.resolve(args: 400, "a400")
 
       XCTAssert(m1.str == "foo")
       XCTAssert(m2.str == "bar")
+      XCTAssert(m3.arg == 40)
+      XCTAssert(m4.arg1 == 400 && m4.arg2 == "a400")
     }
   }