Merge branch 'master' into release/6.0

Swift 4 migration

.swift-version

@@ -1 +1 @@
-3.1
+4

.travis.yml

@@ -12,12 +12,12 @@ matrix:
         - pod spec lint --allow-warnings
         - carthage build --no-skip-current
       os: osx
-      osx_image: xcode8.3
+      osx_image: xcode9
       language: objective-c
       before_install:
         - gem install cocoapods --version 1.1.0.rc.2 --no-document
     - script:
-        - swift build --clean && swift build && swift test
+        - swift package clean && swift build && swift test
       os: linux
       dist: trusty
       sudo: required
@@ -25,13 +25,13 @@ matrix:
       before_install:
         - wget -q -O - https://swift.org/keys/all-keys.asc | gpg --import -
         - cd ..
-        - export SWIFT_VERSION=swift-3.0-RELEASE
-        - wget https://swift.org/builds/swift-3.0-release/ubuntu1404/$SWIFT_VERSION/$SWIFT_VERSION-ubuntu14.04.tar.gz
+        - export SWIFT_VERSION=swift-4.0-RELEASE
+        - wget https://swift.org/builds/swift-4.0-release/ubuntu1404/$SWIFT_VERSION/$SWIFT_VERSION-ubuntu14.04.tar.gz
         - tar xzf $SWIFT_VERSION-ubuntu14.04.tar.gz
         - export PATH="${PWD}/${SWIFT_VERSION}-ubuntu14.04/usr/bin:${PATH}"
         - cd Dip
     - script:
-        - swift build --clean && swift build && swift test
+        - swift package clean && swift build && swift test
       os: linux
       dist: trusty
       sudo: required

CHANGELOG.md

@@ -1,5 +1,12 @@
 # CHANGELOG
 
+## 6.0
+
+* Swift 4 support
+* Fixed unneeded reuse of singletons in collaborating containers. 
+  Containers now first attempt to autowire components and fallback to collaboration when it fails.  
+  [#169](https://github.com/AliSoftware/Dip/issues/169), [@ilyapuchka](https://github.com/ilyapuchka)
+
 ## 5.1
 
 * Dropped Swift 2.3 support.  

Dip.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = "Dip"
-  s.version          = "5.1"
+  s.version          = "6.0"
   s.summary          = "Dependency Injection for Swift made easy."
 
   s.description      = <<-DESC

Dip/Dip.xcodeproj/project.pbxproj

@@ -208,7 +208,7 @@
 			isa = PBXProject;
 			attributes = {
 				LastSwiftUpdateCheck = 0730;
-				LastUpgradeCheck = 0800;
+				LastUpgradeCheck = 0900;
 				ORGANIZATIONNAME = AliSoftware;
 				TargetAttributes = {
 					0903B3571C161543002241C1 = {
@@ -386,20 +386,26 @@
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 5.1;
+				CURRENT_PROJECT_VERSION = 6.0;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
@@ -424,7 +430,7 @@
 				ONLY_ACTIVE_ARCH = YES;
 				SUPPORTED_PLATFORMS = "macosx watchsimulator iphonesimulator appletvsimulator watchos appletvos iphoneos";
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 3.0.2;
+				SWIFT_VERSION = 4.0;
 				TARGETED_DEVICE_FAMILY = "1,2,3,4";
 				TVOS_DEPLOYMENT_TARGET = 9.0;
 				VERSIONING_SYSTEM = "apple-generic";
@@ -441,20 +447,26 @@
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 5.1;
+				CURRENT_PROJECT_VERSION = 6.0;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				ENABLE_NS_ASSERTIONS = NO;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
@@ -472,7 +484,7 @@
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SUPPORTED_PLATFORMS = "macosx watchsimulator iphonesimulator appletvsimulator watchos appletvos iphoneos";
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
-				SWIFT_VERSION = 3.0.2;
+				SWIFT_VERSION = 4.0;
 				TARGETED_DEVICE_FAMILY = "1,2,3,4";
 				TVOS_DEPLOYMENT_TARGET = 9.0;
 				VALIDATE_PRODUCT = YES;

Dip/Dip.xcodeproj/xcshareddata/xcschemes/Dip.xcscheme

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0800"
+   LastUpgradeVersion = "0900"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
@@ -40,6 +40,7 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      language = ""
       shouldUseLaunchSchemeArgsEnv = "YES"
       codeCoverageEnabled = "YES">
       <Testables>
@@ -70,6 +71,7 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      language = ""
       launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"

DipPlayground.playground/Models.remap

@@ -1,176 +1,2 @@
 [
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 54,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 111,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 168,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 228,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 269,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 332,
-  "remove": 3,
-  "text": " ",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 472,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 508,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 613,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 649,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 754,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 808,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 879,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 924,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1092,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1149,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1208,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1265,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1473,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1516,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1569,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1643,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1687,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1762,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1806,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 1848,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 2146,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 2315,
-  "remove": 6,
-  "text": "open",
- },
- {
-  "file": "/Users/ilya/Documents/Developer/iPhoneProjects/Dip/DipPlayground.playground/Sources/Models.swift",
-  "offset": 2357,
-  "remove": 6,
-  "text": "open",
- }
-]
+]

DipPlayground.playground/Pages/Scopes.xcplaygroundpage/Contents.swift

@@ -13,7 +13,7 @@ Dip supports three different scopes of objects: _Unique_, _Shared_ and _Singleto
 * The `Unique` scope will make the `DependencyContainer` resolve your type as __a new instance every time__ you call `resolve`. This is the default scope.
 * The `Shared` scope is like `Unique` scope, but it will make the `DependencyContainer` to reuse resolved instances during one (recursive) call to `resolve` method. When this call returns, all resolved instances will be discarded and next call to `resolve` will produce new instances. This scope should be used to resolve [circular dependencies](Circular%20dependencies).
 * The `Singleton` scope will make the `DependencyContainer` retain the instance once resolved the first time, and reuse it in the next calls to `resolve` during the container lifetime.
-* The `EagerSingleton` scope is the same as `Singleton` scope but instances with this cope will be created when you call `bootstrap()` method on the container.
+* The `EagerSingleton` scope is the same as `Singleton` scope but instances with this scope will be created when you call `bootstrap()` method on the container.
 * The `WeakSingleton` scope is the same as `Singleton` scope but instances are stored in container as weak references. This scope can be usefull when you need to recreate object graph without reseting container.
 
 The `Unique` scope is the default. To set a scope you pass it as an argument to `register` method.

DipPlayground.playground/Pages/Shared Instances.xcplaygroundpage/Contents.swift

@@ -107,7 +107,7 @@ viewController = try MyViewController(apiClient: container.resolve())
 viewController.apiClient = try container.resolve()
 
 /*:
-Of cource `DependencyContainer` should not be a singleton too. There is just no need for that because you never should call `DependencyContainer` from inside of your components. That will make it a [service locator antipatter]((http://blog.ploeh.dk/2010/02/03/ServiceLocatorisanAnti-Pattern/)). You may only call `DependencyContainer` from the _Composition root_ - the place where all the components are configured and wired together.
+Of cource `DependencyContainer` should not be a singleton too. There is just no need for that because you never should call `DependencyContainer` from inside of your components. That will make it a [service locator antipattern]((http://blog.ploeh.dk/2010/02/03/ServiceLocatorisanAnti-Pattern/)). You may only call `DependencyContainer` from the _Composition root_ - the place where all the components are configured and wired together.
 
 Dependency Injection is a pattern (more precisely - a set of patterns) as well as a singleton. And any pattern can be abused. DI can be used in a [wrong way]((http://www.loosecouplings.com/2011/01/dependency-injection-using-di-container.html)), container can easily become a service locator. You should carefully decide when to use DI, you should not inject everything and everywhere and define a protocol for every single class you use. For every tool there is a right time and the same way as singleton can harm you the same way DI and protocols abuse can make your code unnececerry complex.
 

SampleApp/DipSampleApp.xcodeproj/project.pbxproj

@@ -279,7 +279,7 @@
 			isa = PBXProject;
 			attributes = {
 				LastSwiftUpdateCheck = 0700;
-				LastUpgradeCheck = 0800;
+				LastUpgradeCheck = 0900;
 				ORGANIZATIONNAME = AliSoftware;
 				TargetAttributes = {
 					0990225E1BC123C000E76F43 = {
@@ -427,13 +427,21 @@
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
@@ -461,7 +469,7 @@
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 3.0;
+				SWIFT_VERSION = 4.0;
 			};
 			name = Debug;
 		};
@@ -473,13 +481,21 @@
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
@@ -498,7 +514,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 8.3;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = iphoneos;
-				SWIFT_VERSION = 3.0;
+				SWIFT_VERSION = 4.0;
 				VALIDATE_PRODUCT = YES;
 			};
 			name = Release;

SampleApp/DipSampleApp.xcodeproj/xcshareddata/xcschemes/DipSampleApp.xcscheme

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0800"
+   LastUpgradeVersion = "0900"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
@@ -40,6 +40,7 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      language = ""
       shouldUseLaunchSchemeArgsEnv = "YES"
       codeCoverageEnabled = "YES">
       <Testables>
@@ -70,6 +71,7 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      language = ""
       launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"

Sources/AutoInjection.swift

@@ -275,7 +275,7 @@ class _InjectedPropertyBox<T> {
     do {
       container.context.key = container.context.key.tagged(with: tag)
       let key = DefinitionKey(type: T.self, typeOfArguments: Void.self, tag: tag?.dependencyTag)
-      return try resolve(with: container, key: key, builder: { factory in try factory() }) as? T
+      return try resolve(with: container, key: key, builder: { (factory: (Any) throws -> Any) in try factory(()) }) as? T
     }
     catch {
         let error = DipError.autoInjectionFailed(label: container.context.injectedInProperty, type: container.context.resolvingType, underlyingError: error)

Sources/Definition.swift

@@ -23,7 +23,7 @@
 //
 
 ///A key used to store definitons in a container.
-public struct DefinitionKey : Hashable, CustomStringConvertible {
+public struct DefinitionKey: Hashable, CustomStringConvertible {
   public let type: Any.Type
   public let typeOfArguments: Any.Type
   public private(set) var tag: DependencyContainer.Tag?
@@ -47,15 +47,15 @@ public struct DefinitionKey : Hashable, CustomStringConvertible {
     tagged.tag = tag
     return tagged
   }
-  
-}
 
-/// Check two definition keys on equality by comparing their `type`, `factoryType` and `tag` properties.
-public func ==(lhs: DefinitionKey, rhs: DefinitionKey) -> Bool {
-  return
-    lhs.type == rhs.type &&
+  /// Check two definition keys on equality by comparing their `type`, `factoryType` and `tag` properties.
+  public static func ==(lhs: DefinitionKey, rhs: DefinitionKey) -> Bool {
+    return
+      lhs.type == rhs.type &&
       lhs.typeOfArguments == rhs.typeOfArguments &&
       lhs.tag == rhs.tag
+  }
+  
 }
 
 ///Dummy protocol to store definitions for different types in collection
@@ -198,7 +198,7 @@ public final class Definition<T, U>: DefinitionType {
 
 //MARK: - _Definition
 
-protocol _Definition: DefinitionType, AutoWiringDefinition, TypeForwardingDefinition {
+protocol _Definition: AutoWiringDefinition, TypeForwardingDefinition {
   var type: Any.Type { get }
   var scope: ComponentScope { get }
   var weakFactory: ((Any) throws -> Any)! { get }
@@ -208,7 +208,7 @@ protocol _Definition: DefinitionType, AutoWiringDefinition, TypeForwardingDefini
 
 //MARK: - Type Forwarding
 
-protocol _TypeForwardingDefinition: TypeForwardingDefinition, _Definition {
+protocol _TypeForwardingDefinition: _Definition {
   weak var forwardsTo: _TypeForwardingDefinition? { get }
   var forwardsFrom: [_TypeForwardingDefinition] { get set }
   func _implements(type aType: Any.Type)

Sources/Dip.swift

@@ -34,7 +34,7 @@ public final class DependencyContainer {
    
    - seealso: `DependencyTagConvertible`
    */
-  public enum Tag: Equatable {
+  public enum Tag {
     case String(StringLiteralType)
     case Int(IntegerLiteralType)
   }
@@ -167,12 +167,15 @@ extension DependencyContainer {
     /// The label of the property where resolved instance will be auto-injected.
     private(set) public var injectedInProperty: String?
     
+    let inCollaboration: Bool
+    
     var logErrors: Bool = true
     
-    init(key: DefinitionKey, injectedInType: Any.Type?, injectedInProperty: String?) {
+    init(key: DefinitionKey, injectedInType: Any.Type?, injectedInProperty: String?, inCollaboration: Bool) {
       self.key = key
       self.injectedInType = injectedInType
       self.injectedInProperty = injectedInProperty
+      self.inCollaboration = inCollaboration
     }
     
     public var debugDescription: String {
@@ -196,7 +199,7 @@ extension DependencyContainer {
 
   /// Pushes new context created with provided values and calls block. When block returns previous context is restored.
   /// When popped to initial (root) context will release all references to resolved instances and call `Resolvable` callbacks.
-  func inContext<T>(key aKey: DefinitionKey, injectedInType: Any.Type?, injectedInProperty: String? = nil, logErrors: Bool! = nil, block: () throws -> T) rethrows -> T {
+  func inContext<T>(key aKey: DefinitionKey, injectedInType: Any.Type?, injectedInProperty: String? = nil, inCollaboration: Bool = false, container: DependencyContainer? = nil, logErrors: Bool! = nil, block: () throws -> T) rethrows -> T {
     let key = aKey
     return try threadSafe {
       let currentContext = self.context
@@ -207,6 +210,10 @@ extension DependencyContainer {
         //clean instances pool if it is owned not by other container
         if context == nil {
           resolvedInstances.resolvedInstances.removeAll()
+          for (key, instance) in resolvedInstances.sharedWeakSingletons {
+            if resolvedInstances.sharedWeakSingletons[key] is WeakBoxType { continue }
+            resolvedInstances.sharedWeakSingletons[key] = WeakBox(instance)
+          }
           for (key, instance) in resolvedInstances.weakSingletons {
             if resolvedInstances.weakSingletons[key] is WeakBoxType { continue }
             resolvedInstances.weakSingletons[key] = WeakBox(instance)
@@ -222,7 +229,8 @@ extension DependencyContainer {
       context = Context(
         key: key,
         injectedInType: injectedInType,
-        injectedInProperty: injectedInProperty
+        injectedInProperty: injectedInProperty,
+        inCollaboration: inCollaboration
       )
       context.logErrors = logErrors ?? currentContext?.logErrors ?? true
       
@@ -258,17 +266,17 @@ extension DependencyContainer {
     _collaborators += containers
     for container in containers {
       container._collaborators += [self]
-      container.resolvedInstances.singletonsBox = self.resolvedInstances.singletonsBox
-      container.resolvedInstances.weakSingletonsBox = self.resolvedInstances.weakSingletonsBox
+      container.resolvedInstances.sharedSingletonsBox = self.resolvedInstances.sharedSingletonsBox
+      container.resolvedInstances.sharedWeakSingletonsBox = self.resolvedInstances.sharedWeakSingletonsBox
       updateCollaborationReferences(between: container, and: self)
     }
   }
   
   private func updateCollaborationReferences(between container: DependencyContainer, and collaborator: DependencyContainer) {
     for container in container._collaborators {
-      guard container.resolvedInstances.singletonsBox !== collaborator.resolvedInstances.singletonsBox else { continue }
-      container.resolvedInstances.singletonsBox = collaborator.resolvedInstances.singletonsBox
-      container.resolvedInstances.weakSingletonsBox = collaborator.resolvedInstances.weakSingletonsBox
+      guard container.resolvedInstances.sharedSingletonsBox !== collaborator.resolvedInstances.sharedSingletonsBox else { continue }
+      container.resolvedInstances.sharedSingletonsBox = collaborator.resolvedInstances.sharedSingletonsBox
+      container.resolvedInstances.sharedWeakSingletonsBox = collaborator.resolvedInstances.sharedWeakSingletonsBox
       updateCollaborationReferences(between: container, and: collaborator)
     }
   }
@@ -291,11 +299,23 @@ extension DependencyContainer {
         let context = collaborator.context
         collaborator.context = self.context
         defer {
-          collaborator.resolvedInstances = resolvedInstances
           collaborator.context = context
+          collaborator.resolvedInstances = resolvedInstances
+          
+          for (key, resolvedSingleton) in self.resolvedInstances.singletons {
+            collaborator.resolvedInstances.singletons[aKey] = resolvedSingleton
+          }
+          for (_, resolvedSingleton) in self.resolvedInstances.weakSingletons {
+            guard collaborator.definition(matching: aKey) != nil else { continue }
+            collaborator.resolvedInstances.weakSingletons[aKey] = WeakBox(resolvedSingleton)
+          }
+          for (_, resolved) in self.resolvedInstances.resolvedInstances {
+            guard collaborator.definition(matching: aKey) != nil else { continue }
+            collaborator.resolvedInstances.resolvedInstances[aKey] = resolved
+          }
         }
         
-        let resolved = try collaborator.inContext(key:key, injectedInType: self.context.injectedInType, injectedInProperty: self.context.injectedInProperty, logErrors: false) {
+        let resolved = try collaborator.inContext(key:key, injectedInType: self.context.injectedInType, injectedInProperty: self.context.injectedInProperty, inCollaboration: true, logErrors: false) {
           try collaborator._resolve(key: key, builder: builder)
         }
 
@@ -336,6 +356,8 @@ extension DependencyContainer {
       definitions[key] = nil
       resolvedInstances.singletons[key] = nil
       resolvedInstances.weakSingletons[key] = nil
+      resolvedInstances.sharedSingletons[key] = nil
+      resolvedInstances.sharedWeakSingletons[key] = nil
     }
   }
 
@@ -348,6 +370,8 @@ extension DependencyContainer {
       definitions.removeAll()
       resolvedInstances.singletons.removeAll()
       resolvedInstances.weakSingletons.removeAll()
+      resolvedInstances.sharedSingletons.removeAll()
+      resolvedInstances.sharedWeakSingletons.removeAll()
       bootstrapped = false
     }
   }
@@ -477,13 +501,17 @@ extension DependencyContainer.Tag: ExpressibleByIntegerLiteral {
   
 }
 
-public func ==(lhs: DependencyContainer.Tag, rhs: DependencyContainer.Tag) -> Bool {
-  switch (lhs, rhs) {
-  case let (.String(lhsString), .String(rhsString)):
-    return lhsString == rhsString
-  case let (.Int(lhsInt), .Int(rhsInt)):
-    return lhsInt == rhsInt
-  default:
-    return false
+extension DependencyContainer.Tag: Equatable {
+
+  public static func ==(lhs: DependencyContainer.Tag, rhs: DependencyContainer.Tag) -> Bool {
+    switch (lhs, rhs) {
+    case let (.String(lhsString), .String(rhsString)):
+      return lhsString == rhsString
+    case let (.Int(lhsInt), .Int(rhsInt)):
+      return lhsInt == rhsInt
+    default:
+      return false
+    }
   }
+
 }

Sources/Register.swift

@@ -71,6 +71,8 @@ extension DependencyContainer {
       definitions[key] = definition
       resolvedInstances.singletons[key] = nil
       resolvedInstances.weakSingletons[key] = nil
+      resolvedInstances.sharedSingletons[key] = nil
+      resolvedInstances.sharedWeakSingletons[key] = nil
       
       if .eagerSingleton == definition.scope {
         bootstrapQueue.append({ _ = try self.resolve(tag: tag) as T })

Sources/Resolve.swift

@@ -46,7 +46,7 @@ extension DependencyContainer {
    - seealso: `register(_:type:tag:factory:)`
    */
   public func resolve<T>(tag: DependencyTagConvertible? = nil) throws -> T {
-    return try resolve(tag: tag) { factory in try factory() }
+    return try _resolve(tag: tag) { (factory: () throws -> T) in try factory() }
   }
 
   /**
@@ -73,7 +73,7 @@ extension DependencyContainer {
    - seealso: `resolve(tag:)`, `register(_:type:tag:factory:)`
    */
   public func resolve(_ type: Any.Type, tag: DependencyTagConvertible? = nil) throws -> Any {
-    return try resolve(type, tag: tag) { factory in try factory() }
+    return try resolve(type, tag: tag) { (factory: () throws -> Any) in try factory() }
   }
   
   /**
@@ -103,7 +103,11 @@ extension DependencyContainer {
   public func resolve<T, U>(tag: DependencyTagConvertible? = nil, builder: ((U) throws -> T) throws -> T) throws -> T {
     return try _resolve(tag: tag, builder: builder)
   }
-  
+
+  public func resolve<T>(tag: DependencyTagConvertible? = nil, builder: (() throws -> T) throws -> T) throws -> T {
+    return try _resolve(tag: tag, builder: builder)
+  }
+
   /**
    Resolve an instance of provided type using builder closure. Weakly-typed alternative of `resolve(tag:builder:)`
    
@@ -113,13 +117,37 @@ extension DependencyContainer {
     return try _resolve(type: type, tag: tag, builder: builder)
   }
 
+  public func resolve(_ type: Any.Type, tag: DependencyTagConvertible? = nil, builder: (() throws -> Any) throws -> Any) throws -> Any {
+    return try _resolve(type: type, tag: tag, builder: builder)
+  }
+
 }
 
 extension DependencyContainer {
   
+  func _resolve<T>(tag aTag: DependencyTagConvertible? = nil, builder: (() throws -> T) throws -> T) throws -> T {
+    return try resolve(T.self, tag: aTag, builder: { factory in
+      try withoutActuallyEscaping(factory, do: { (factory) throws -> T in
+        try builder({ try factory() as! T })
+      })
+    }) as! T
+  }
+  
+  func _resolve(type aType: Any.Type, tag: DependencyTagConvertible? = nil, builder: (() throws -> Any) throws -> Any) throws -> Any {
+    let key = DefinitionKey(type: aType, typeOfArguments: Void.self, tag: tag?.dependencyTag)
+    
+    return try inContext(key:key, injectedInType: context?.resolvingType) {
+      try self._resolve(key: key, builder: { definition in
+        try builder { try definition.weakFactory(()) }
+      })
+    }
+  }
+  
   func _resolve<T, U>(tag aTag: DependencyTagConvertible? = nil, builder: ((U) throws -> T) throws -> T) throws -> T {
     return try resolve(T.self, tag: aTag, builder: { factory in
-      try builder({ try factory($0) as! T })
+      try withoutActuallyEscaping(factory, do: { (factory) throws -> T in
+        try builder({ try factory($0) as! T })
+      })
     }) as! T
   }
   
@@ -136,7 +164,15 @@ extension DependencyContainer {
   /// Lookup definition by the key and use it to resolve instance. Fallback to the key with `nil` tag.
   func _resolve<T>(key aKey: DefinitionKey, builder: (_Definition) throws -> T) throws -> T {
     guard let matching = self.definition(matching: aKey) else {
-      return try collaboratingResolve(key: aKey, builder: builder) ?? autowire(key: aKey)
+      do {
+        return try autowire(key: aKey)
+      } catch {
+        if let resolved = collaboratingResolve(key: aKey, builder: builder) {
+          return resolved
+        } else {
+          throw error
+        }
+      }
     }
     
     let (key, definition) = matching
@@ -175,7 +211,7 @@ extension DependencyContainer {
       return previouslyResolved
     }
     
-    resolvedInstances[key: key, inScope: definition.scope] = resolvedInstance
+    resolvedInstances[key: key, inScope: definition.scope, context: context] = resolvedInstance
     
     if let resolvable = resolvedInstance as? Resolvable {
       resolvedInstances.resolvableInstances.append(resolvable)
@@ -191,7 +227,7 @@ extension DependencyContainer {
   
   private func previouslyResolved<T>(for definition: _Definition, key: DefinitionKey) -> T? {
     //first check if exact key was already resolved
-    if let previouslyResolved = resolvedInstances[key: key, inScope: definition.scope] as? T {
+    if let previouslyResolved = resolvedInstances[key: key, inScope: definition.scope, context: context] as? T {
       return previouslyResolved
     }
     //then check if any related type was already resolved
@@ -199,7 +235,7 @@ extension DependencyContainer {
       DefinitionKey(type: $0, typeOfArguments: key.typeOfArguments, tag: key.tag)
     })
     for key in keys {
-      if let previouslyResolved = resolvedInstances[key: key, inScope: definition.scope] as? T {
+      if let previouslyResolved = resolvedInstances[key: key, inScope: definition.scope, context: context] as? T {
         return previouslyResolved
       }
     }
@@ -207,7 +243,7 @@ extension DependencyContainer {
   }
   
   /// Searches for definition that matches provided key
-  private func definition(matching key: DefinitionKey) -> KeyDefinitionPair? {
+  func definition(matching key: DefinitionKey) -> KeyDefinitionPair? {
     if let definition = (self.definitions[key] ?? self.definitions[key.tagged(with: nil)]) {
       return (key, definition)
     }
@@ -230,41 +266,47 @@ class ResolvedInstances {
   var resolvableInstances = [Resolvable]()
   
   //singletons are stored using reference type wrapper to be able to share them between containers
-  var singletonsBox = Box<[DefinitionKey: Any]>([:])
-  var singletons: [DefinitionKey: Any] {
-    get { return singletonsBox.unboxed }
-    set { singletonsBox.unboxed = newValue }
+  var sharedSingletonsBox = Box<[DefinitionKey: Any]>([:])
+  var sharedSingletons: [DefinitionKey: Any] {
+    get { return sharedSingletonsBox.unboxed }
+    set { sharedSingletonsBox.unboxed = newValue }
   }
+  var singletons = [DefinitionKey: Any]()
   
-  var weakSingletonsBox = Box<[DefinitionKey: Any]>([:])
-  var weakSingletons: [DefinitionKey: Any] {
-    get { return weakSingletonsBox.unboxed }
-    set { weakSingletonsBox.unboxed = newValue }
+  var sharedWeakSingletonsBox = Box<[DefinitionKey: Any]>([:])
+  var sharedWeakSingletons: [DefinitionKey: Any] {
+    get { return sharedWeakSingletonsBox.unboxed }
+    set { sharedWeakSingletonsBox.unboxed = newValue }
   }
+  var weakSingletons = [DefinitionKey: Any]()
   
-  subscript(key key: DefinitionKey, inScope scope: ComponentScope) -> Any? {
+  subscript(key key: DefinitionKey, inScope scope: ComponentScope, context context: DependencyContainer.Context) -> Any? {
     get {
-      if scope == .singleton || scope == .eagerSingleton {
-        return singletons[key]
-      }
-      if scope == .weakSingleton {
-        if let boxed = weakSingletons[key] as? WeakBoxType { return boxed.unboxed }
-        else { return weakSingletons[key] }
-      }
-      if scope == .shared {
+      switch scope {
+      case .singleton, .eagerSingleton:
+        return context.inCollaboration ? sharedSingletons[key] : singletons[key]
+      case .weakSingleton:
+        let singletons = context.inCollaboration ? sharedWeakSingletons : weakSingletons
+        if let boxed = singletons[key] as? WeakBoxType { return boxed.unboxed }
+        else { return singletons[key] }
+      case .shared:
         return resolvedInstances[key]
+      case .unique:
+        return nil
       }
-      return nil
     }
     set {
-      if scope == .singleton || scope == .eagerSingleton {
+      switch scope {
+      case .singleton, .eagerSingleton:
+        sharedSingletons[key] = newValue
         singletons[key] = newValue
-      }
-      if scope == .weakSingleton {
+      case .weakSingleton:
+        sharedWeakSingletons[key] = newValue
         weakSingletons[key] = newValue
-      }
-      if scope == .shared {
+      case .shared:
         resolvedInstances[key] = newValue
+      case .unique:
+        break
       }
     }
   }

Sources/RuntimeArguments.swift

@@ -65,7 +65,7 @@ extension DependencyContainer {
    container.register(Client.self, factory: ClientImp.init(service:))
    ```
    */
-  @discardableResult public func register<T>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping () throws -> T) -> Definition<T, ()> {
+  @discardableResult public func register<T>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (()) throws -> T) -> Definition<T, ()> {
     let definition = DefinitionBuilder<T, ()> {
       $0.scope = scope
       $0.factory = factory
@@ -127,7 +127,7 @@ extension DependencyContainer {
   
   - seealso: `register(_:type:tag:factory:)`
   */
-  @discardableResult public func register<T, A>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A) throws -> T) -> Definition<T, A> {
+  @discardableResult public func register<T, A>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping ((A)) throws -> T) -> Definition<T, A> {
     return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 1) { container, tag in try factory(container.resolve(tag: tag)) }
   }
 
@@ -167,13 +167,14 @@ extension DependencyContainer {
   // MARK: 2 Runtime Arguments
   
   /// - seealso: `register(_:type:tag:factory:)`
-  @discardableResult public func register<T, A, B>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B) throws -> T) -> Definition<T, (A, B)> {
-    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 2) { container, tag in try factory(container.resolve(tag: tag), container.resolve(tag: tag)) }
+  @discardableResult public func register<T, A, B>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping ((A, B)
+    ) throws -> T) -> Definition<T, (A, B)> {
+    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 2) { container, tag in try factory((container.resolve(tag: tag), container.resolve(tag: tag))) }
   }
 
   /// - seealso: `resolve(tag:arguments:)`
   public func resolve<T, A, B>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B) throws -> T {
-    return try resolve(tag: tag) { factory in try factory(arg1, arg2) }
+    return try resolve(T.self, tag: tag) { factory in try factory((arg1, arg2)) } as! T
   }
   
   ///- seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
@@ -184,13 +185,13 @@ extension DependencyContainer {
   // MARK: 3 Runtime Arguments
   
   /// - seealso: `register(_:type:tag:factory:)`
-  @discardableResult public func register<T, A, B, C>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B, C) throws -> T) -> Definition<T, (A, B, C)> {
-    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 3)  { container, tag in try factory(container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag)) }
+  @discardableResult public func register<T, A, B, C>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping ((A, B, C)) throws -> T) -> Definition<T, (A, B, C)> {
+    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 3)  { container, tag in try factory((container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag))) }
   }
 
   /// - seealso: `resolve(tag:arguments:)`
   public func resolve<T, A, B, C>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C) throws -> T {
-    return try resolve(tag: tag) { factory in try factory(arg1, arg2, arg3) }
+    return try resolve(T.self, tag: tag) { factory in try factory((arg1, arg2, arg3)) } as! T
   }
   
   ///- seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
@@ -201,13 +202,13 @@ extension DependencyContainer {
   // MARK: 4 Runtime Arguments
   
   /// - seealso: `register(_:type:tag:factory:)`
-  @discardableResult public func register<T, A, B, C, D>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B, C, D) throws -> T) -> Definition<T, (A, B, C, D)> {
-    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 4) { container, tag in try factory(container.resolve(tag: tag),  container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag)) }
+  @discardableResult public func register<T, A, B, C, D>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping ((A, B, C, D)) throws -> T) -> Definition<T, (A, B, C, D)> {
+    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 4) { container, tag in try factory((container.resolve(tag: tag),  container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag))) }
   }
 
   /// - seealso: `resolve(tag:arguments:)`
   public func resolve<T, A, B, C, D>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C, _ arg4: D) throws -> T {
-    return try resolve(tag: tag) { factory in try factory(arg1, arg2, arg3, arg4) }
+    return try resolve(T.self, tag: tag) { factory in try factory((arg1, arg2, arg3, arg4)) } as! T
   }
 
   /// - seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
@@ -218,13 +219,13 @@ extension DependencyContainer {
   // MARK: 5 Runtime Arguments
   
   /// - seealso: `register(_:type:tag:factory:)`
-  @discardableResult public func register<T, A, B, C, D, E>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B, C, D, E) throws -> T) -> Definition<T, (A, B, C, D, E)> {
-    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 5) { container, tag in try factory(container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag)) }
+  @discardableResult public func register<T, A, B, C, D, E>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping ((A, B, C, D, E)) throws -> T) -> Definition<T, (A, B, C, D, E)> {
+    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 5) { container, tag in try factory((container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag))) }
   }
 
   /// - seealso: `resolve(tag:arguments:)`
   public func resolve<T, A, B, C, D, E>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C, _ arg4: D, _ arg5: E) throws -> T {
-    return try resolve(tag: tag) { factory in try factory(arg1, arg2, arg3, arg4, arg5) }
+    return try resolve(T.self, tag: tag) { factory in try factory((arg1, arg2, arg3, arg4, arg5)) } as! T
   }
 
   ///- seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`
@@ -235,13 +236,13 @@ extension DependencyContainer {
   // MARK: 6 Runtime Arguments
   
   /// - seealso: `register(_:type:tag:factory:)`
-  @discardableResult public func register<T, A, B, C, D, E, F>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping (A, B, C, D, E, F) throws -> T) -> Definition<T, (A, B, C, D, E, F)> {
-    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 6) { container, tag in try factory(container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag)) }
+  @discardableResult public func register<T, A, B, C, D, E, F>(_ scope: ComponentScope = .shared, type: T.Type = T.self, tag: DependencyTagConvertible? = nil, factory: @escaping ((A, B, C, D, E, F)) throws -> T) -> Definition<T, (A, B, C, D, E, F)> {
+    return register(scope: scope, type: type, tag: tag, factory: factory, numberOfArguments: 6) { container, tag in try factory((container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag), container.resolve(tag: tag))) }
   }
 
   /// - seealso: `resolve(tag:arguments:)`
   public func resolve<T, A, B, C, D, E, F>(tag: DependencyTagConvertible? = nil, arguments arg1: A, _ arg2: B, _ arg3: C, _ arg4: D, _ arg5: E, _ arg6: F) throws -> T {
-    return try resolve(tag: tag) { factory in try factory(arg1, arg2, arg3, arg4, arg5, arg6) }
+    return try resolve(T.self, tag: tag) { factory in try factory((arg1, arg2, arg3, arg4, arg5, arg6)) } as! T
   }
 
   /// - seealso: `resolve(_:tag:)`, `resolve(tag:arguments:)`

Sources/TypeForwarding.swift

@@ -81,12 +81,6 @@ extension Definition {
     return implements(a).implements(b).implements(c)
   }
 
-  ///Registers definition for types passed as parameters
-  @available(*, deprecated: 5.1.0)
-  @discardableResult public func implements<A, B, C, D>(_ a: A.Type, _ b: B.Type, c: C.Type, d: D.Type) -> Definition {
-    return implements(a).implements(b).implements(c).implements(d)
-  }
-  
   ///Registers definition for types passed as parameters
   @discardableResult public func implements<A, B, C, D>(_ a: A.Type, _ b: B.Type, _ c: C.Type, _ d: D.Type) -> Definition {
     return implements(a).implements(b).implements(c).implements(d)

Tests/DipTests/AutoWiringTests.swift

@@ -112,7 +112,7 @@ class AutoWiringTests: XCTestCase {
     //2 args
     var factoryWithMostNumberOfArgumentsCalled = false
     container.register { AutoWiredClientImp(service1: $0, service2: $1) as AutoWiredClient }
-      .resolvingProperties { _ in
+      .resolvingProperties { _,_  in
         factoryWithMostNumberOfArgumentsCalled = true
     }
     
@@ -164,7 +164,7 @@ class AutoWiringTests: XCTestCase {
     container.register(tag: "tag") { AutoWiredClientImp(service1: $0, service2: try self.container.resolve()) as AutoWiredClient }
     
     //2 arg tagged
-    container.register(tag: "tag") { AutoWiredClientImp(service1: $0, service2: $1) as AutoWiredClient }.resolvingProperties { _ in
+    container.register(tag: "tag") { AutoWiredClientImp(service1: $0, service2: $1) as AutoWiredClient }.resolvingProperties { _,_  in
       taggedFactoryWithMostNumberOfArgumentsCalled = true
     }
 
@@ -189,7 +189,7 @@ class AutoWiringTests: XCTestCase {
     
     //1 arg tagged
     var taggedFactoryCalled = false
-    container.register(tag: "tag") { AutoWiredClientImp(service1: try self.container.resolve(), service2: $0) as AutoWiredClient }.resolvingProperties { _ in
+    container.register(tag: "tag") { AutoWiredClientImp(service1: try self.container.resolve(), service2: $0) as AutoWiredClient }.resolvingProperties { _,_  in
       taggedFactoryCalled = true
     }
     
@@ -208,7 +208,7 @@ class AutoWiringTests: XCTestCase {
     
     //1 arg
     var notTaggedFactoryWithMostNumberOfArgumentsCalled = false
-    container.register { AutoWiredClientImp(service1: $0, service2: try self.container.resolve()) as AutoWiredClient }.resolvingProperties { _ in
+    container.register { AutoWiredClientImp(service1: $0, service2: try self.container.resolve()) as AutoWiredClient }.resolvingProperties { _,_  in
       notTaggedFactoryWithMostNumberOfArgumentsCalled = true
     }
     

Tests/DipTests/ContextTests.swift

@@ -63,7 +63,7 @@ class ContextTests: XCTestCase {
       XCTAssertTrue(self.container.context.resolvingType == Service.self)
       let _ = try self.container.resolve() as ServiceImp1
       return ServiceImp1() as Service
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertTrue(self.container.context.resolvingType == Service.self)
         let _ = try self.container.resolve() as ServiceImp1
     }
@@ -71,7 +71,7 @@ class ContextTests: XCTestCase {
     container.register { () -> ServiceImp1 in
       XCTAssertTrue(self.container.context.resolvingType == ServiceImp1.self)
       return ServiceImp1()
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertTrue(self.container.context.resolvingType == ServiceImp1.self)
     }
     
@@ -83,7 +83,7 @@ class ContextTests: XCTestCase {
       XCTAssertNil(self.container.context.injectedInType)
       let _ = try self.container.resolve() as ServiceImp1
       return ServiceImp1() as Service
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertNil(self.container.context.injectedInType)
         let _ = try self.container.resolve() as ServiceImp1
     }
@@ -91,7 +91,7 @@ class ContextTests: XCTestCase {
     container.register { () -> ServiceImp1 in
       XCTAssertTrue(self.container.context.injectedInType == Service.self)
       return ServiceImp1()
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertTrue(self.container.context.injectedInType == Service.self)
     }
     
@@ -104,7 +104,7 @@ class ContextTests: XCTestCase {
       XCTAssertTrue(DependencyContainer.Tag.String("tag") ~= self.container.context.tag!)
       let _ = try self.container.resolve(tag: "otherTag") as ServiceImp1
       return ServiceImp1() as Service
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertNotNil(self.container.context.tag)
         XCTAssertTrue(DependencyContainer.Tag.String("tag") ~= self.container.context.tag!)
         let _ = try self.container.resolve(tag: "otherTag") as ServiceImp1
@@ -114,7 +114,7 @@ class ContextTests: XCTestCase {
       XCTAssertNotNil(self.container.context.tag)
       XCTAssertTrue(DependencyContainer.Tag.String("otherTag") ~= self.container.context.tag!)
       return ServiceImp1()
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertNotNil(self.container.context.tag)
         XCTAssertTrue(DependencyContainer.Tag.String("otherTag") ~= self.container.context.tag!)
     }
@@ -135,7 +135,7 @@ class ContextTests: XCTestCase {
         XCTAssertTrue(DependencyContainer.Tag.String("injectedTag") ~= self.container.context.tag!)
       }
       return ServiceImp2()
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         if self.container.context.injectedInProperty == "injectedNilTag" {
           XCTAssertNil(self.container.context.tag)
         }
@@ -149,7 +149,7 @@ class ContextTests: XCTestCase {
       XCTAssertNotNil(self.container.context.tag)
       XCTAssertTrue(DependencyContainer.Tag.String("tag") ~= self.container.context.tag!)
       return ServiceImp2()
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertNotNil(self.container.context.tag)
         XCTAssertTrue(DependencyContainer.Tag.String("tag") ~= self.container.context.tag!)
     }
@@ -160,14 +160,14 @@ class ContextTests: XCTestCase {
   func testThatContextStoresTheTagPassedToResolveWhenAutoWiring() {
     container.register { (_: ServiceImp1) -> Service in
       return ServiceImp1() as Service
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
     }
     
     container.register { () -> ServiceImp1 in
       XCTAssertNotNil(self.container.context.tag)
       XCTAssertTrue(DependencyContainer.Tag.String("tag") ~= self.container.context.tag!)
       return ServiceImp1()
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertNotNil(self.container.context.tag)
         XCTAssertTrue(DependencyContainer.Tag.String("tag") ~= self.container.context.tag!)
     }
@@ -181,7 +181,7 @@ class ContextTests: XCTestCase {
       XCTAssertTrue(DependencyContainer.Tag.String("tag") ~= self.container.context.tag!)
       let _ = try self.container.resolve() as ServiceImp1
       return ServiceImp1() as Service
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertNotNil(self.container.context.tag)
         XCTAssertTrue(DependencyContainer.Tag.String("tag") ~= self.container.context.tag!)
         let _ = try self.container.resolve() as ServiceImp1
@@ -190,7 +190,7 @@ class ContextTests: XCTestCase {
     container.register { () -> ServiceImp1 in
       XCTAssertNil(self.container.context.tag)
       return ServiceImp1()
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertNil(self.container.context.tag)
     }
     
@@ -207,7 +207,7 @@ class ContextTests: XCTestCase {
       XCTAssertNotNil(self.container.context.injectedInProperty)
       XCTAssertTrue(names.contains(self.container.context.injectedInProperty!))
       return ServiceImp2()
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertNotNil(self.container.context.injectedInProperty)
         XCTAssertTrue(names.contains(self.container.context.injectedInProperty!))
     }
@@ -239,7 +239,7 @@ class ContextTests: XCTestCase {
       XCTAssertTrue(self.container.context.resolvingType == Service.self)
       let _ = try self.container.resolve() as ServiceImp1
       return ServiceImp1() as Service
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertTrue(self.container.context.resolvingType == Service.self)
         let _ = try self.container.resolve() as ServiceImp1
     }
@@ -247,7 +247,7 @@ class ContextTests: XCTestCase {
     collaborator.register { () -> ServiceImp1 in
       XCTAssertTrue(collaborator.context.resolvingType == ServiceImp1.self)
       return ServiceImp1()
-      }.resolvingProperties { _ in
+      }.resolvingProperties { _,_  in
         XCTAssertTrue(collaborator.context.resolvingType == ServiceImp1.self)
     }
     

Tests/DipTests/DipTests.swift

@@ -573,12 +573,12 @@ class DipTests: XCTestCase {
       }.implements(Service.self)
     
     container.register(tag: "tag") { ServiceImp2() as Service }
-      .resolvingProperties { _ in
+      .resolvingProperties { _,_  in
         createdService2 = true
     }
     
     container.register { (arg: String) in ServiceImp1() }
-      .resolvingProperties { _ in
+      .resolvingProperties { _,_  in
         createdService3 = true
     }
     
@@ -743,16 +743,16 @@ extension DipTests {
     let collaborator4 = DependencyContainer()
     
     collaborator1.collaborate(with: container)
-    XCTAssertTrue(collaborator1.resolvedInstances.singletonsBox === container.resolvedInstances.singletonsBox)
+    XCTAssertTrue(collaborator1.resolvedInstances.sharedSingletonsBox === container.resolvedInstances.sharedSingletonsBox)
 
     collaborator2.collaborate(with: container)
-    XCTAssertTrue(collaborator2.resolvedInstances.singletonsBox === container.resolvedInstances.singletonsBox)
+    XCTAssertTrue(collaborator2.resolvedInstances.sharedSingletonsBox === container.resolvedInstances.sharedSingletonsBox)
 
     collaborator3.collaborate(with: collaborator1)
-    XCTAssertTrue(collaborator3.resolvedInstances.singletonsBox === container.resolvedInstances.singletonsBox)
+    XCTAssertTrue(collaborator3.resolvedInstances.sharedSingletonsBox === container.resolvedInstances.sharedSingletonsBox)
 
     collaborator4.collaborate(with: collaborator2)
-    XCTAssertTrue(collaborator4.resolvedInstances.singletonsBox === container.resolvedInstances.singletonsBox)
+    XCTAssertTrue(collaborator4.resolvedInstances.sharedSingletonsBox === container.resolvedInstances.sharedSingletonsBox)
     
     let service1 = try! collaborator1.resolve() as Service
     let service2 = try! collaborator2.resolve() as Service
@@ -760,10 +760,74 @@ extension DipTests {
     let service4 = try! collaborator4.resolve() as Service
     let serviceRoot = try! container.resolve() as Service
     
+    XCTAssertTrue(service1 === service2)
+    XCTAssertTrue(service1 === service3)
+    XCTAssertTrue(service1 === service4)
+    
     XCTAssertTrue(service1 === serviceRoot)
     XCTAssertTrue(service2 === serviceRoot)
     XCTAssertTrue(service3 === serviceRoot)
     XCTAssertTrue(service4 === serviceRoot)
   }
-  
+
+  class RootService {}
+  class ServiceClient {
+    let name: String
+    let service: RootService
+    init(name: String, service: RootService) {
+      self.name = name
+      self.service = service
+    }
+  }
+
+  func testThatContainersShareTheirSingletonsOnlyWithCollaborators() {
+    let container = DependencyContainer()
+    container.register(.singleton) { RootService() }
+    
+    let collaborator1 = DependencyContainer()
+    collaborator1.register(.singleton) {
+      ServiceClient(name: "1", service: $0)
+    }
+    
+    let collaborator2 = DependencyContainer()
+    collaborator2.register(.singleton) {
+      ServiceClient(name: "2", service: $0)
+    }
+    
+    collaborator1.collaborate(with: container)
+    collaborator2.collaborate(with: container)
+    
+    let client2 = try! collaborator2.resolve() as ServiceClient
+    let client1 = try! collaborator1.resolve() as ServiceClient
+    
+    XCTAssertEqual(client1.name, "1")
+    XCTAssertEqual(client2.name, "2")
+    XCTAssertTrue(client1.service === client2.service)
+  }
+
+  func testThatContainerAutowireBeforeCollaboration() {
+    let container = DependencyContainer()
+    container.register(.singleton) { RootService() }
+    
+    let collaborator1 = DependencyContainer()
+    collaborator1.register(.singleton) {
+      ServiceClient(name: "1", service: $0)
+    }
+    
+    let collaborator2 = DependencyContainer()
+    collaborator2.register(.singleton) {
+      ServiceClient(name: "2", service: $0)
+    }
+    
+    collaborator1.collaborate(with: container, collaborator2)
+    collaborator2.collaborate(with: container, collaborator1)
+    
+    let client2 = try! collaborator2.resolve() as ServiceClient
+    let client1 = try! collaborator1.resolve() as ServiceClient
+    
+    XCTAssertEqual(client1.name, "1")
+    XCTAssertEqual(client2.name, "2")
+    XCTAssertTrue(client1.service === client2.service)
+  }
+
 }

Tests/DipTests/TypeForwardingTests.swift

@@ -154,9 +154,9 @@ class TypeForwardingTests: XCTestCase {
     var originalResolvingPropertiesCalled = false
     var resolvingPropertiesCalled = false
     container.register { ServiceImp1() }
-      .resolvingProperties { _ in
+      .resolvingProperties { _,_  in
         originalResolvingPropertiesCalled = true
-      }.implements(Service.self) { _ in
+      }.implements(Service.self) { _,_ in
         resolvingPropertiesCalled = true
       }
     
@@ -184,11 +184,11 @@ class TypeForwardingTests: XCTestCase {
     var resolvingPropertiesCalled = false
     container.reset()
     let definition = container.register { ServiceImp1() }
-      .implements(Service.self) { container, object in
+      .implements(Service.self) { _,_ in
         resolvingPropertiesCalled = true
     }
     
-    definition.resolvingProperties { _ in
+    definition.resolvingProperties { _,_  in
       originalResolvingPropertiesCalled = true
     }