Turn Knit.Resolver into a class type

Example/KnitExample/ContentView.swift

@@ -7,7 +7,7 @@ import SwiftUI
 
 struct ContentView: View {
 
-    let resolver: Resolver
+    let resolver: BaseResolver
 
     var body: some View {
         VStack {
@@ -21,7 +21,7 @@ struct ContentView: View {
 }
 
 struct ContentView_Previews: PreviewProvider {
-    static let assembler = ScopedModuleAssembler<Resolver>([KnitExampleAssembly()])
+    static let assembler = ScopedModuleAssembler<BaseResolver>([KnitExampleAssembly()])
     static var previews: some View {
         return ContentView(resolver: assembler.resolver)
     }

Example/KnitExample/KnitExampleApp.swift

@@ -8,12 +8,12 @@ import Knit
 @main
 struct KnitExampleApp: App {
 
-    let assembler: ScopedModuleAssembler<Resolver>
-    var resolver: Resolver { assembler.resolver }
+    let assembler: ScopedModuleAssembler<BaseResolver>
+    var resolver: BaseResolver { assembler.resolver }
 
     @MainActor
     init() {
-        assembler = ScopedModuleAssembler<Resolver>(
+        assembler = ScopedModuleAssembler<BaseResolver>(
             [KnitExampleAssembly()]
         )
     }

Example/KnitExample/KnitExampleAssembly.swift

@@ -9,7 +9,7 @@ import KnitMacros
 // @knit internal
 final class KnitExampleAssembly: ModuleAssembly {
 
-    typealias TargetResolver = Resolver
+    typealias TargetResolver = BaseResolver
 
     static var dependencies: [any ModuleAssembly.Type] { [] }
 

Example/KnitExample/KnitExampleUserAssembly.swift

@@ -9,7 +9,7 @@ import Knit
 /// An assembly expected to be registered at the user level rather than at the app level
 final class KnitExampleUserAssembly: ModuleAssembly {
 
-    typealias TargetResolver = Resolver
+    typealias TargetResolver = BaseResolver
 
     static var dependencies: [any ModuleAssembly.Type] { [] }
 

Sources/Knit/Container.swift

@@ -11,24 +11,11 @@ import Swinject
 
  The Knit.Container also performs the function of a weak wrapper of the `SwinjectContainer`.
  */
-public class Container<TargetResolver>: Knit.Resolver {
+public class Container<TargetResolver: Knit.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: - SwinjectResolver
-
-    public func unsafeResolver(file: StaticString, function: StaticString, line: UInt) -> SwinjectResolver {
-        _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: SwinjectContainer) {
         self._swinjectContainer = _swinjectContainer
+        self.resolver = TargetResolver(_swinjectContainer: _swinjectContainer)
     }
 }
 

Sources/Knit/Module/ModuleAssembly.swift

@@ -7,7 +7,7 @@ import Swinject
 
 public protocol ModuleAssembly<TargetResolver> {
 
-    associatedtype TargetResolver
+    associatedtype TargetResolver: Knit.Resolver
 
     static var resolverType: Self.TargetResolver.Type { get }
 
@@ -20,10 +20,6 @@ public protocol ModuleAssembly<TargetResolver> {
     /// A common case is a fake assembly that registers fake services matching those from the original module.
     static var replaces: [any ModuleAssembly.Type] { get }
 
-    /// Filter the list of dependencies down to those which match the scope of this assembly
-    /// This can be overridden in apps with custom Resolver hierarchies
-    static func scoped(_ dependencies: [any ModuleAssembly.Type]) -> [any ModuleAssembly.Type]
-
     /// Hints about this assembly using by DependencyBuilder. Designed for internal use
     static var _assemblyFlags: [ModuleAssemblyFlags] { get }
 
@@ -39,13 +35,6 @@ 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
-        }
-    }
-
     static var _assemblyFlags: [ModuleAssemblyFlags] {
         var result: [ModuleAssemblyFlags] = []
         if self is any AutoInitModuleAssembly.Type {
@@ -84,6 +73,13 @@ public protocol GeneratedModuleAssembly: ModuleAssembly {
 extension ModuleAssembly where Self: GeneratedModuleAssembly {
     // Default the dependencies to using generatedDependencies scoped to those with compatible resolvers
     public static var dependencies: [any ModuleAssembly.Type] { scoped(generatedDependencies) }
+
+    /// Filter the list of dependencies down to those which match the scope of this assembly
+    public static func scoped(_ dependencies: [any ModuleAssembly.Type]) -> [any ModuleAssembly.Type] {
+        return dependencies.filter { module in
+            return resolverType.inherits(from: module.resolverType)
+        }
+    }
 }
 
 /// Control the behavior of Assembly Overrides.

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: Knit.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,

Sources/Knit/Resolver.swift

@@ -13,4 +13,58 @@ public protocol Resolver: AnyObject {
 
     func unsafeResolver(file: StaticString, function: StaticString, line: UInt) -> SwinjectResolver
 
+    init(_swinjectContainer: SwinjectContainer)
+
+    /// Resolvers require a manual implementation that matches the inheritance structure of the Resolver
+    /// If ResolverB inherits from ResolverA then the ResolverB inherits function should match this
+    /// Example:
+    /// public func ResolverB: ResolverA {
+    ///   static func inherits(from resolverType: Resolver.Type) -> Bool {
+    ///    return self == resolverType || resolverType == ResolverA.self
+    ///   }
+    /// }
+    static func inherits(from resolverType: Resolver.Type) -> Bool
+
+}
+
+/// Default Resolver implementation. Designed to be inherited from
+open class BaseResolver: Resolver {
+
+    private weak var _swinjectContainer: SwinjectContainer?
+
+    /// Returns `true` if the backing container is still available in memory, otherwise `false`.
+    public var isAvailable: Bool {
+        _swinjectContainer != nil
+    }
+
+    // MARK: - SwinjectResolver
+
+    public func unsafeResolver(file: StaticString, function: StaticString, line: UInt) -> SwinjectResolver {
+        _unwrappedSwinjectContainer(file: file, function: function, line: line)
+    }
+
+    public required init(_swinjectContainer: SwinjectContainer) {
+        self._swinjectContainer = _swinjectContainer
+    }
+
+    /// Default implementation uses pure equality
+    open 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
+    ) -> SwinjectContainer {
+        guard let _swinjectContainer else {
+            fatalError(
+                "\(function) incorrectly accessed the container for \(self) which has already been released",
+                file: file,
+                line: line
+            )
+        }
+        return _swinjectContainer
+    }
 }

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)
                 }
             }