Create a class based Knit Resolver

skorulis-ap · skorulis-ap · commit cf400127038f · 2025-08-26T20:11:02.000+10:00
diff --git a/Sources/Knit/Container.swift b/Sources/Knit/Container.swift
@@ -11,24 +11,11 @@ import Swinject
 
  The Knit.Container also performs the function of a weak wrapper of the `Swinject.Container`.
  */
-public class Container<TargetResolver>: Knit.Resolver {
+public class Container<TargetResolver: Resolver> {
 
     // MARK: - Knit.Resolver
 
-    public var resolver: TargetResolver {
-        self as! TargetResolver
-    }
-
-    /// Returns `true` if the backing container is still available in memory, otherwise `false`.
-    public var isAvailable: Bool {
-        _swinjectContainer != nil
-    }
-
-    // MARK: - Swinject.Resolver
-
-    public func unsafeResolver(file: StaticString, function: StaticString, line: UInt) -> Swinject.Resolver {
-        _unwrappedSwinjectContainer(file: file, function: function, line: line)
-    }
+    public let resolver: TargetResolver
 
     // MARK: - Private Properties
 
@@ -39,6 +26,7 @@ public class Container<TargetResolver>: Knit.Resolver {
     // This should not be promoted from `fileprivate` access level.
     fileprivate init(_swinjectContainer: Swinject.Container) {
         self._swinjectContainer = _swinjectContainer
+        self.resolver = TargetResolver(_swinjectContainer: _swinjectContainer)
     }
 }
 
diff --git a/Sources/Knit/Module/ModuleAssembly.swift b/Sources/Knit/Module/ModuleAssembly.swift
@@ -7,7 +7,7 @@ import Swinject
 
 public protocol ModuleAssembly<TargetResolver> {
 
-    associatedtype TargetResolver
+    associatedtype TargetResolver: Resolver
 
     static var resolverType: Self.TargetResolver.Type { get }
 
@@ -40,9 +40,8 @@ public extension ModuleAssembly {
     static var replaces: [any ModuleAssembly.Type] { [] }
 
     static func scoped(_ dependencies: [any ModuleAssembly.Type]) -> [any ModuleAssembly.Type] {
-        return dependencies.filter {
-            // Default the scoped implementation to match types directly
-            return self.resolverType == $0.resolverType
+        return dependencies.filter { module in
+            return resolverType.inherits(from: module.resolverType)
         }
     }
 
diff --git a/Sources/Knit/Module/ScopedModuleAssembler.swift b/Sources/Knit/Module/ScopedModuleAssembler.swift
@@ -6,7 +6,7 @@ import Foundation
 import Swinject
 
 /// Module assembly which only allows registering assemblies which target a particular resolver type.
-public final class ScopedModuleAssembler<TargetResolver> {
+public final class ScopedModuleAssembler<TargetResolver: Resolver> {
 
     public let internalAssembler: ModuleAssembler
 
@@ -58,18 +58,6 @@ public final class ScopedModuleAssembler<TargetResolver> {
         behaviors: [Behavior] = [],
         postAssemble: ((Container<TargetResolver>) -> Void)? = nil
     ) throws {
-        // For provided modules, fail early if they are scoped incorrectly
-        for assembly in modules {
-            let moduleAssemblyType = type(of: assembly)
-            if moduleAssemblyType.resolverType != TargetResolver.self {
-                let scopingError = ScopedModuleAssemblerError.incorrectTargetResolver(
-                    expected: String(describing: TargetResolver.self),
-                    actual: String(describing: moduleAssemblyType.resolverType)
-                )
-
-                throw DependencyBuilderError.assemblyValidationFailure(moduleAssemblyType, reason: scopingError)
-            }
-        }
         self.internalAssembler = try ModuleAssembler(
             parent: parent,
             _modules: modules,
diff --git a/Sources/Knit/Resolver.swift b/Sources/Knit/Resolver.swift
@@ -13,4 +13,50 @@ public protocol Resolver: AnyObject {
 
     func unsafeResolver(file: StaticString, function: StaticString, line: UInt) -> Swinject.Resolver
 
+    init(_swinjectContainer: Swinject.Container)
+
+    static func inherits(from resolverType: Resolver.Type) -> Bool
+
+}
+
+/// Default Resolver implementation. Designed to be inherited from
+open class RealResolver: Resolver {
+
+    private weak var _swinjectContainer: Swinject.Container?
+
+    /// Returns `true` if the backing container is still available in memory, otherwise `false`.
+    public var isAvailable: Bool {
+        _swinjectContainer != nil
+    }
+
+    // MARK: - Swinject.Resolver
+
+    public func unsafeResolver(file: StaticString, function: StaticString, line: UInt) -> Swinject.Resolver {
+        _unwrappedSwinjectContainer(file: file, function: function, line: line)
+    }
+
+    public required init(_swinjectContainer: Swinject.Container) {
+        self._swinjectContainer = _swinjectContainer
+    }
+
+    /// Default implementation uses pure equality
+    public class func inherits(from resolverType: Resolver.Type) -> Bool {
+        return self == resolverType
+    }
+
+    // Force unwraps the weak Container
+    func _unwrappedSwinjectContainer(
+        file: StaticString = #fileID,
+        function: StaticString = #function,
+        line: UInt = #line
+    ) -> Swinject.Container {
+        guard let _swinjectContainer else {
+            fatalError(
+                "\(function) incorrectly accessed the container for \(self) which has already been released",
+                file: file,
+                line: line
+            )
+        }
+        return _swinjectContainer
+    }
 }
diff --git a/Sources/Knit/ServiceCollection/Container+ServiceCollection.swift b/Sources/Knit/ServiceCollection/Container+ServiceCollection.swift
@@ -30,7 +30,7 @@ extension Container {
             name: makeUniqueCollectionRegistrationName(),
             factory: { r in
                 MainActor.assumeIsolated {
-                    let resolver = r.resolve(Container<TargetResolver>.self)! as! TargetResolver
+                    let resolver = r.resolve(Container<TargetResolver>.self)!.resolver
                     return factory(resolver)
                 }
             }
diff --git a/Sources/Knit/ServiceCollection/Resolver+ServiceCollection.swift b/Sources/Knit/ServiceCollection/Resolver+ServiceCollection.swift
@@ -29,7 +29,7 @@ extension Swinject.Resolver {
 
 // MARK: - Knit Resolver
 
-extension Knit.Resolver {
+extension RealResolver {
 
     /// Resolves a collection of all services registered using
     /// ``Container/registerIntoCollection(_:factory:)``
diff --git a/Tests/KnitTests/ModuleAssemblyScopingTests.swift b/Tests/KnitTests/ModuleAssemblyScopingTests.swift
@@ -23,15 +23,13 @@ final class ModuleAssemblyScopingTests: XCTestCase {
 
 }
 
-private protocol ParentResolver: Resolver {}
-private protocol ChildResolver: Resolver {}
-private protocol OtherResolver: Resolver {}
-
-extension ChildResolver {
-    static func contains(resolver: Resolver.Type) -> Bool {
-        return resolver == self || resolver == ParentResolver.self
+private class ParentResolver: RealResolver {}
+private class ChildResolver: ParentResolver {
+    public override class func inherits(from resolverType: Resolver.Type) -> Bool {
+        return resolverType == self || resolverType == ParentResolver.self
     }
 }
+private class OtherResolver: RealResolver {}
 
 private struct Assembly1: GeneratedModuleAssembly {
     typealias TargetResolver = ParentResolver
@@ -56,15 +54,3 @@ private struct Assembly4: GeneratedModuleAssembly {
     static var generatedDependencies: [any ModuleAssembly.Type] { [Assembly1.self] }
     func assemble(container: Container<Self.TargetResolver>) {}
 }
-
-private extension ModuleAssembly {
-    // Override the default scoping function to allow assemblies using ParentResolver to be included in ChildResolver
-    static func scoped(_ dependencies: [any ModuleAssembly.Type]) -> [any ModuleAssembly.Type] {
-        return dependencies.filter {
-            if self.resolverType == ChildResolver.self && $0.resolverType == ParentResolver.self {
-                return true
-            }
-            return self.resolverType == $0.resolverType
-        }
-    }
-}
diff --git a/Tests/KnitTests/ScopedModuleAssemblerTests.swift b/Tests/KnitTests/ScopedModuleAssemblerTests.swift
@@ -66,7 +66,7 @@ private struct Assembly1: AutoInitModuleAssembly {
     func assemble(container: Knit.Container<Self.TargetResolver>) { }
 }
 
-protocol OutsideResolver: Swinject.Resolver { }
+class OutsideResolver: RealResolver { }
 
 private struct Assembly2: AutoInitModuleAssembly {
     typealias TargetResolver = OutsideResolver
diff --git a/Tests/KnitTests/ServiceCollectorTests.swift b/Tests/KnitTests/ServiceCollectorTests.swift
@@ -6,11 +6,9 @@
 import Swinject
 import XCTest
 
-private protocol ParentResolver: Knit.Resolver {}
-private protocol ChildResolver: ParentResolver {}
-private protocol GrandChildResolver: ChildResolver {}
-
-extension Knit.Container: ParentResolver, ChildResolver, GrandChildResolver {}
+private class ParentResolver: RealResolver {}
+private class ChildResolver: ParentResolver {}
+private class GrandChildResolver: ChildResolver {}
 
 private protocol ServiceProtocol {}
 
@@ -87,7 +85,7 @@ final class ServiceCollectorTests: XCTestCase {
     @MainActor
     func test_registerIntoCollection() {
         let swinjectContainer = Swinject.Container()
-        let container = ContainerManager(swinjectContainer: swinjectContainer).register(Any.self)
+        let container = ContainerManager(swinjectContainer: swinjectContainer).register(ParentResolver.self)
         container._unwrappedSwinjectContainer().addBehavior(ServiceCollector())
 
         // Register some services into a collection
@@ -99,12 +97,12 @@ final class ServiceCollectorTests: XCTestCase {
         container.registerIntoCollection(CustomService.self) { _ in CustomService(name: "Custom 2") }
 
         // Resolving each collection should produce the expected services
-        let serviceProtocolCollection = container.resolveCollection(ServiceProtocol.self)
+        let serviceProtocolCollection = container.resolver.resolveCollection(ServiceProtocol.self)
         XCTAssertEqual(serviceProtocolCollection.entries.count, 2)
         XCTAssert(serviceProtocolCollection.entries.first is ServiceA)
         XCTAssert(serviceProtocolCollection.entries.last is ServiceB)
 
-        let customServiceCollection = container.resolveCollection(CustomService.self)
+        let customServiceCollection = container.resolver.resolveCollection(CustomService.self)
         XCTAssertEqual(
             customServiceCollection.entries.map(\.name),
             ["Custom 1", "Custom 2"]
@@ -114,19 +112,19 @@ final class ServiceCollectorTests: XCTestCase {
     @MainActor
     func test_registerIntoCollection_emptyWithBehavior() {
         let swinjectContainer = Swinject.Container()
-        let container = ContainerManager(swinjectContainer: swinjectContainer).register(Any.self)
+        let container = ContainerManager(swinjectContainer: swinjectContainer).register(ParentResolver.self)
         container._unwrappedSwinjectContainer().addBehavior(ServiceCollector())
 
-        let collection = container.resolveCollection(ServiceProtocol.self)
+        let collection = container.resolver.resolveCollection(ServiceProtocol.self)
         XCTAssertEqual(collection.entries.count, 0)
     }
 
     @MainActor
     func test_registerIntoCollection_emptyWithoutBehavior() {
         let swinjectContainer = Swinject.Container()
-        let container = ContainerManager(swinjectContainer: swinjectContainer).register(Any.self)
+        let container = ContainerManager(swinjectContainer: swinjectContainer).register(ParentResolver.self)
 
-        let collection = container.resolveCollection(ServiceProtocol.self)
+        let collection = container.resolver.resolveCollection(ServiceProtocol.self)
         XCTAssertEqual(collection.entries.count, 0)
     }
 
@@ -135,7 +133,7 @@ final class ServiceCollectorTests: XCTestCase {
     @MainActor
     func test_registerIntoCollection_doesntConflictWithArray() throws {
         let swinjectContainer = Swinject.Container()
-        let container = ContainerManager(swinjectContainer: swinjectContainer).register(Any.self)
+        let container = ContainerManager(swinjectContainer: swinjectContainer).register(ParentResolver.self)
         container._unwrappedSwinjectContainer().addBehavior(ServiceCollector())
 
         // Register A into a collection
@@ -145,7 +143,7 @@ final class ServiceCollectorTests: XCTestCase {
         container.register([ServiceProtocol].self) { _ in [ServiceB()] }
 
         // Resolving the collection should produce A
-        let collection = container.resolveCollection(ServiceProtocol.self)
+        let collection = container.resolver.resolveCollection(ServiceProtocol.self)
         XCTAssertEqual(collection.entries.count, 1)
         XCTAssert(collection.entries.first is ServiceA)
 
@@ -158,7 +156,7 @@ final class ServiceCollectorTests: XCTestCase {
     @MainActor
     func test_registerIntoCollection_doesntImplicitlyAggregateInstances() throws {
         let swinjectContainer = Swinject.Container()
-        let container = ContainerManager(swinjectContainer: swinjectContainer).register(Any.self)
+        let container = ContainerManager(swinjectContainer: swinjectContainer).register(ParentResolver.self)
         container._unwrappedSwinjectContainer().addBehavior(ServiceCollector())
 
         // Register A and B into a collection
@@ -169,7 +167,7 @@ final class ServiceCollectorTests: XCTestCase {
         _ = container.register(ServiceProtocol.self) { _ in ServiceB() }
 
         // Resolving the collection should produce A and B
-        let collection = container.resolveCollection(ServiceProtocol.self)
+        let collection = container.resolver.resolveCollection(ServiceProtocol.self)
         XCTAssertEqual(collection.entries.count, 2)
         XCTAssert(collection.entries.first is ServiceA)
         XCTAssert(collection.entries.last is ServiceB)
@@ -181,7 +179,7 @@ final class ServiceCollectorTests: XCTestCase {
     @MainActor
     func test_registerIntoCollection_allowsDuplicates() {
         let swinjectContainer = Swinject.Container()
-        let container = ContainerManager(swinjectContainer: swinjectContainer).register(Any.self)
+        let container = ContainerManager(swinjectContainer: swinjectContainer).register(ParentResolver.self)
         container._unwrappedSwinjectContainer().addBehavior(ServiceCollector())
 
         // Register some duplicate services
@@ -190,7 +188,7 @@ final class ServiceCollectorTests: XCTestCase {
         _ = container.registerIntoCollection(ServiceProtocol.self) { _ in CustomService(name: "Car Repair") }
 
         // Resolving the collection should produce all services
-        let collection = container.resolveCollection(ServiceProtocol.self)
+        let collection = container.resolver.resolveCollection(ServiceProtocol.self)
         XCTAssertEqual(
             collection.entries.compactMap { ($0 as? CustomService)?.name },
             ["Dry Cleaning", "Car Repair", "Car Repair"]
@@ -202,7 +200,7 @@ final class ServiceCollectorTests: XCTestCase {
     @MainActor
     func test_registerIntoCollection_supportsTransientScopedObjects() throws {
         let swinjectContainer = Swinject.Container()
-        let container = ContainerManager(swinjectContainer: swinjectContainer).register(Any.self)
+        let container = ContainerManager(swinjectContainer: swinjectContainer).register(ParentResolver.self)
         container._unwrappedSwinjectContainer().addBehavior(ServiceCollector())
 
         // Register a service with the `transient` scope.
@@ -211,8 +209,8 @@ final class ServiceCollectorTests: XCTestCase {
             .registerIntoCollection(CustomService.self) { _ in CustomService(name: "service") }
             .inObjectScope(.transient)
 
-        let collection1 = container.resolveCollection(CustomService.self)
-        let collection2 = container.resolveCollection(CustomService.self)
+        let collection1 = container.resolver.resolveCollection(CustomService.self)
+        let collection2 = container.resolver.resolveCollection(CustomService.self)
 
         let instance1 = try XCTUnwrap(collection1.entries.first)
         let instance2 = try XCTUnwrap(collection2.entries.first)
@@ -223,7 +221,7 @@ final class ServiceCollectorTests: XCTestCase {
     @MainActor
     func test_registerIntoCollection_supportsContainerScopedObjects() throws {
         let swinjectContainer = Swinject.Container()
-        let container = ContainerManager(swinjectContainer: swinjectContainer).register(Any.self)
+        let container = ContainerManager(swinjectContainer: swinjectContainer).register(ParentResolver.self)
         container._unwrappedSwinjectContainer().addBehavior(ServiceCollector())
 
         // Register a service with the `container` scope.
@@ -232,8 +230,8 @@ final class ServiceCollectorTests: XCTestCase {
             .registerIntoCollection(CustomService.self) { _ in CustomService(name: "service") }
             .inObjectScope(.container)
 
-        let collection1 = container.resolveCollection(CustomService.self)
-        let collection2 = container.resolveCollection(CustomService.self)
+        let collection1 = container.resolver.resolveCollection(CustomService.self)
+        let collection2 = container.resolver.resolveCollection(CustomService.self)
 
         let instance1 = try XCTUnwrap(collection1.entries.first)
         let instance2 = try XCTUnwrap(collection2.entries.first)
@@ -244,7 +242,7 @@ final class ServiceCollectorTests: XCTestCase {
     @MainActor
     func test_registerIntoCollection_supportsWeakScopedObjects() throws {
         let swinjectContainer = Swinject.Container()
-        let container = ContainerManager(swinjectContainer: swinjectContainer).register(Any.self)
+        let container = ContainerManager(swinjectContainer: swinjectContainer).register(ParentResolver.self)
         container._unwrappedSwinjectContainer().addBehavior(ServiceCollector())
 
         // Register a service with the `weak` scope.
@@ -259,18 +257,18 @@ final class ServiceCollectorTests: XCTestCase {
             .inObjectScope(.weak)
 
         // Resolve the initial instance
-        var instance1: CustomService? = try XCTUnwrap(container.resolveCollection(CustomService.self).entries.first)
+        var instance1: CustomService? = try XCTUnwrap(container.resolver.resolveCollection(CustomService.self).entries.first)
         XCTAssertEqual(factoryCallCount, 1)
 
         // Resolving again shouldn't increase `factoryCallCount` since `instance1` is still retained.
-        var instance2: CustomService? = try XCTUnwrap(container.resolveCollection(CustomService.self).entries.first)
+        var instance2: CustomService? = try XCTUnwrap(container.resolver.resolveCollection(CustomService.self).entries.first)
         XCTAssertEqual(factoryCallCount, 1)
         XCTAssert(instance2 === instance1)
 
         // Release our instances and resolve again. This time a new instance should be created.
         instance1 = nil
         instance2 = nil
-        _ = container.resolveCollection(CustomService.self)
+        _ = container.resolver.resolveCollection(CustomService.self)
         XCTAssertEqual(factoryCallCount, 2)
     }
 
diff --git a/Tests/KnitTests/SynchronizationTests.swift b/Tests/KnitTests/SynchronizationTests.swift
diff --git a/Tests/KnitTests/TestResolver.swift b/Tests/KnitTests/TestResolver.swift

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ import Swinject`
`7`	`7`
`8`	`8`	`public protocol ModuleAssembly<TargetResolver> {`
`9`	`9`
`10`		`- associatedtype TargetResolver`
	`10`	`+ associatedtype TargetResolver: Resolver`
`11`	`11`
`12`	`12`	`static var resolverType: Self.TargetResolver.Type { get }`
`13`	`13`
`@@ -40,9 +40,8 @@ public extension ModuleAssembly {`
`40`	`40`	`static var replaces: [any ModuleAssembly.Type] { [] }`
`41`	`41`
`42`	`42`	`static func scoped(_ dependencies: [any ModuleAssembly.Type]) -> [any ModuleAssembly.Type] {`
`43`		`- return dependencies.filter {`
`44`		`- // Default the scoped implementation to match types directly`
`45`		`- return self.resolverType == $0.resolverType`
	`43`	`+ return dependencies.filter { module in`
	`44`	`+ return resolverType.inherits(from: module.resolverType)`
`46`	`45`	`}`
`47`	`46`	`}`
`48`	`47`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ extension Container {`
`30`	`30`	`name: makeUniqueCollectionRegistrationName(),`
`31`	`31`	`factory: { r in`
`32`	`32`	`MainActor.assumeIsolated {`
`33`		`- let resolver = r.resolve(Container<TargetResolver>.self)! as! TargetResolver`
	`33`	`+ let resolver = r.resolve(Container<TargetResolver>.self)!.resolver`
`34`	`34`	`return factory(resolver)`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ private struct Assembly1: AutoInitModuleAssembly {`
`66`	`66`	`func assemble(container: Knit.Container<Self.TargetResolver>) { }`
`67`	`67`	`}`
`68`	`68`
`69`		`-protocol OutsideResolver: Swinject.Resolver { }`
	`69`	`+class OutsideResolver: RealResolver { }`
`70`	`70`
`71`	`71`	`private struct Assembly2: AutoInitModuleAssembly {`
`72`	`72`	`typealias TargetResolver = OutsideResolver`