Dependencies referenced with a different name than their resolved registration where crashing at runtime

trupin · trupin · commit f4c0942a554e · 2020-06-18T18:31:34.000-07:00
diff --git a/Sample/API/Generated/Weaver.swift b/Sample/API/Generated/Weaver.swift
@@ -101,16 +101,16 @@ final class MainDependencyContainer {
 
     private func movieAPIDependencyResolver() -> MovieAPIDependencyResolver {
         let _self = MainDependencyContainer()
-        _self.builders["urlSession"] = _self.builder(urlSession)
         _self.builders["logger"] = lazyBuilder { (_: Optional<ParametersCopier>) -> Logger in return Logger() }
+        _self.builders["urlSession"] = _self.builder(urlSession)
         _ = _self.getBuilder(for: "logger", type: Logger.self)(nil)
         return _self
     }
 
     fileprivate func publicMovieAPIDependencyResolver(urlSession: URLSession) -> MovieAPIDependencyResolver {
         let _self = MainDependencyContainer()
-        _self.builders["urlSession"] = _self.builder(urlSession)
         _self.builders["logger"] = lazyBuilder { (_: Optional<ParametersCopier>) -> Logger in return Logger() }
+        _self.builders["urlSession"] = _self.builder(urlSession)
         _ = _self.getBuilder(for: "logger", type: Logger.self)(nil)
         return _self
     }
@@ -157,6 +157,7 @@ final class MainDependencyContainer {
             let __self = _self.movieAPIDependencyResolver()
             return MovieAPI(injecting: __self)
         }
+        _self.builders["logger"] = _self.builder(_self.logger)
         _ = _self.getBuilder(for: "urlSession", type: URLSession.self)(nil)
         _ = _self.getBuilder(for: "movieAPI", type: APIProtocol.self)(nil)
         return _self
@@ -165,8 +166,6 @@ final class MainDependencyContainer {
     fileprivate func publicMovieManagerDependencyResolver(host: Optional<String>,
                                                           logger: Logger) -> MovieManagerDependencyResolver {
         let _self = MainDependencyContainer()
-        _self.builders["host"] = _self.builder(host)
-        _self.builders["logger"] = _self.builder(logger)
         _self.builders["urlSession"] = lazyBuilder { [weak _self] (_: Optional<ParametersCopier>) -> URLSession in
             guard let _self = _self else {
                 MainDependencyContainer.fatalError()
@@ -180,6 +179,8 @@ final class MainDependencyContainer {
             let __self = _self.movieAPIDependencyResolver()
             return MovieAPI(injecting: __self)
         }
+        _self.builders["host"] = _self.builder(host)
+        _self.builders["logger"] = _self.builder(logger)
         _ = _self.getBuilder(for: "urlSession", type: URLSession.self)(nil)
         _ = _self.getBuilder(for: "movieAPI", type: APIProtocol.self)(nil)
         return _self
diff --git a/Sample/Sample/Generated/Weaver.swift b/Sample/Sample/Generated/Weaver.swift
@@ -232,6 +232,7 @@ import UIKit
     private func personManagerDependencyResolver() -> PersonManagerDependencyResolver {
         let _self = MainDependencyContainer()
         _self.builders["logger"] = lazyBuilder { (_: Optional<ParametersCopier>) -> Logger in return Logger() }
+        _self.builders["movieAPI"] = _self.builder(_self.movieAPI)
         _ = _self.getBuilder(for: "logger", type: Logger.self)(nil)
         MainDependencyContainer._pushDynamicResolver({ _self.logger })
         MainDependencyContainer._pushDynamicResolver({ _self.movieAPI })
@@ -240,8 +241,8 @@ import UIKit
 
     private func reviewManagerDependencyResolver() -> ReviewManagerDependencyResolver {
         let _self = MainDependencyContainer()
-        _self.builders["movieAPI"] = _self.builder(movieAPI)
         _self.builders["logger"] = lazyBuilder { (_: Optional<ParametersCopier>) -> Logger in return Logger() }
+        _self.builders["movieAPI"] = _self.builder(movieAPI)
         _ = _self.getBuilder(for: "logger", type: Logger.self)(nil)
         MainDependencyContainer._pushDynamicResolver({ _self.logger })
         MainDependencyContainer._pushDynamicResolver({ _self.movieAPI })
@@ -250,9 +251,6 @@ import UIKit
 
     private func homeViewControllerDependencyResolver() -> HomeViewControllerDependencyResolver {
         let _self = MainDependencyContainer()
-        _self.builders["imageManager"] = _self.builder(imageManager)
-        _self.builders["movieManager"] = _self.builder(movieManager)
-        _self.builders["reviewManager"] = _self.builder(reviewManager)
         _self.builders["logger"] = lazyBuilder { (_: Optional<ParametersCopier>) -> Logger in return Logger() }
         _self.builders["movieController"] = weakLazyBuilder { [weak _self] (copyParameters: Optional<ParametersCopier>) -> UIViewController in
             defer { MainDependencyContainer._dynamicResolversLock.unlock() }
@@ -264,6 +262,9 @@ import UIKit
             copyParameters?(__self as! MainDependencyContainer)
             return MovieViewController(injecting: __self)
         }
+        _self.builders["imageManager"] = _self.builder(imageManager)
+        _self.builders["movieManager"] = _self.builder(movieManager)
+        _self.builders["reviewManager"] = _self.builder(reviewManager)
         _ = _self.getBuilder(for: "logger", type: Logger.self)(nil)
         MainDependencyContainer._pushDynamicResolver({ _self.logger })
         MainDependencyContainer._pushDynamicResolver({ _self.movieManager })
@@ -273,16 +274,16 @@ import UIKit
 
     private func movieViewControllerDependencyResolver() -> MovieViewControllerDependencyResolver {
         let _self = MainDependencyContainer()
-        _self.builders["imageManager"] = _self.builder(imageManager)
-        _self.builders["movieManager"] = _self.builder(movieManager)
-        _self.builders["reviewManager"] = _self.builder(reviewManager)
         _self.builders["logger"] = lazyBuilder { (_: Optional<ParametersCopier>) -> Logger in return Logger() }
         _self.builders["reviewController"] = weakLazyBuilder { [weak _self] (_: Optional<ParametersCopier>) -> WSReviewViewController in
             guard let _self = _self else {
                 MainDependencyContainer.fatalError()
             }
             return WSReviewViewController.make(_self as WSReviewViewControllerInputDependencyResolver)
         }
+        _self.builders["imageManager"] = _self.builder(imageManager)
+        _self.builders["movieManager"] = _self.builder(movieManager)
+        _self.builders["reviewManager"] = _self.builder(reviewManager)
         _ = _self.getBuilder(for: "logger", type: Logger.self)(nil)
         MainDependencyContainer._pushDynamicResolver({ _self.logger })
         MainDependencyContainer._pushDynamicResolver({ _self.movieID })
diff --git a/Sources/WeaverCodeGen/Inspector.swift b/Sources/WeaverCodeGen/Inspector.swift
@@ -32,6 +32,13 @@ public final class Inspector {
     }
 }
 
+// MARK: - Inspection Level
+
+enum InspectionLevel {
+    case aggressive
+    case permissive
+}
+
 // MARK: - Resolution Check
 
 extension Inspector {
@@ -42,7 +49,9 @@ extension Inspector {
         return try resolve(dependency, from: source)
     }
     
-    func resolve(_ dependency: Dependency, from source: DependencyContainer) throws -> [ConcreteType: Dependency] {
+    func resolve(_ dependency: Dependency,
+                 from source: DependencyContainer,
+                 inspectionLevel: InspectionLevel = .aggressive) throws -> [ConcreteType: Dependency] {
         
         guard dependency.kind == .reference else {
             return [source.type: dependency]
@@ -53,7 +62,9 @@ extension Inspector {
         }
                 
         do {
-            guard try checkIsolation(of: source, history: []) else { return [:] }
+            if inspectionLevel == .aggressive {
+                guard try checkIsolation(of: source, history: []) else { return [:] }
+            }
             
             let sources = [source.type] + Array(source.sources)
             return try sources.reduce(into: [ConcreteType: Dependency]()) { foundDependencies, sourceType in
diff --git a/Sources/WeaverCodeGen/SwiftGenerator.swift b/Sources/WeaverCodeGen/SwiftGenerator.swift
@@ -756,45 +756,59 @@ static func _pushDynamicResolver<Resolver>(_ resolver: Resolver) {
                     return FunctionParameter(name: declaration.declarationName, type: declaration.type.typeID)
                 } : [])
                 .adding(member: Assignment(variable: Variable._self, value: TypeIdentifier.mainDependencyContainer.reference | .call()))
-                .adding(members: try inputReferences.compactMap { reference in
-                    
+                .adding(members: try dependencyContainer.registrations.compactMap { registration in
+                    try copyAssignment(for: registration, from: dependencyContainer)
+                })
+                .adding(members: try inputReferences.flatMap { reference -> [FunctionBodyMember] in
+
                     let declaration = try self.declaration(for: reference)
-                    guard selfReferenceDeclarations.contains(declaration) == false else { return nil }
+                    guard selfReferenceDeclarations.contains(declaration) == false else { return [] }
 
-                    let assignment: (MetaDependencyDeclaration) -> Assignment = { resolvedDeclaration in
-                        Assignment(
-                            variable: Variable._self.reference + .named(declaration.buildersSubcriptGet),
-                            value: Variable._self.reference + .named("builder") | .call(Tuple()
-                                .adding(parameter: TupleParameter(value: Reference.named(resolvedDeclaration.declarationName)))
-                            )
+                    let assignments: (MetaDependencyDeclaration) -> [Assignment] = { resolvedDeclaration in
+                        let isRootDependencyContainer = dependencyContainer.sources.isEmpty && publicInterface == false
+                        let builderValue = Variable._self.reference + .named("builder") | .call(Tuple()
+                            .adding(parameter: TupleParameter(value:
+                                (isRootDependencyContainer ? Variable._self.reference + .none : .none) | .named(resolvedDeclaration.declarationName)
+                            ))
                         )
+
+                        var assignments = [Assignment(
+                            variable: Variable._self.reference + .named(declaration.buildersSubcriptGet),
+                            value: builderValue
+                        )]
+
+                        if resolvedDeclaration.declarationName != declaration.declarationName {
+                            assignments += [Assignment(
+                                variable: Variable._self.reference + .named(resolvedDeclaration.buildersSubcriptGet),
+                                value: builderValue
+                            )]
+                        }
+
+                        return assignments
                     }
 
                     if publicInterface {
-                        return assignment(declaration)
+                        return assignments(declaration)
                     } else {
                         let resolvedDeclarations = try resolvedDeclarationsBySource(for: reference, in: dependencyContainer)
                         if resolvedDeclarations.count > 1 {
-                            return Switch(reference: Variable.source.reference)
+                            return [Switch(reference: Variable.source.reference)
                                 .adding(cases: resolvedDeclarations.compactMap { source, declaration in
                                     guard let source = source else { return nil }
                                     return SwitchCase()
                                         .adding(value: Value.string(source.description))
-                                        .adding(member: assignment(declaration))
+                                        .adding(members: assignments(declaration))
                                 })
                                 .adding(case: SwitchCase(name: .default)
                                     .adding(member: TypeIdentifier.mainDependencyContainer.reference + .named("fatalError") | .call())
-                                )
+                                )]
                         } else if let resolvedDeclaration = resolvedDeclarations.first?.declaration {
-                            return assignment(resolvedDeclaration)
+                            return assignments(resolvedDeclaration)
                         } else {
-                            return nil
+                            return []
                         }
                     }
                 })
-                .adding(members: try dependencyContainer.registrations.compactMap { registration in
-                    try copyAssignment(for: registration, from: dependencyContainer)
-                })
                 .adding(members: try dependencyContainer.registrations.compactMap { registration in
                     guard registration.configuration.setter == false else { return nil }
                     switch registration.configuration.scope {
@@ -1272,15 +1286,15 @@ private extension MetaWeaverFile {
         
         switch dependency.kind {
         case .reference:
-            guard dependencyContainer.sources.isEmpty == false else { return [] }
-            
             do {
-                let registrations = try inspector.resolve(dependency, from: dependencyContainer)
+                let registrations = try inspector.resolve(dependency, from: dependencyContainer, inspectionLevel: .permissive)
                 
                 let resolvedDeclarations: [(ConcreteType?, MetaDependencyDeclaration)] = try registrations.lazy.sorted { lhs, rhs in
                     lhs.key.description < rhs.key.description
                 }.compactMap { source, registration in
-                    guard dependencyContainer.sources.contains(source) else { return nil }
+                    let isRootDependencyContainer = dependencyContainer.sources.isEmpty
+                    let sources = isRootDependencyContainer ? [dependencyContainer.type] : dependencyContainer.sources
+                    guard sources.contains(source) else { return nil }
                     return (source, try self.declaration(for: registration))
                 }
                 
