     from originalExecutor: Executor? = nil
     ) -> Bool {
 
-    let (oldState, handlers) = _locking
-      .locker(self, completion) { (self_, completion) -> (PromiseState<Success>, [PromiseHandler<Success>]?) in
+    let (oldState, completionResult) = _locking
+      .locker(self, completion) { (self_, completion) -> (PromiseState<Success>, PromiseStateCompletionResult<Success>) in
       let oldState = self_._state
-      let (newState, handlers) = oldState.complete(completion: completion)
+      let (newState, completionResult) = oldState.complete(completion: completion)
       self_._state = newState
-      return (oldState, handlers)
+      return (oldState, completionResult)
     }
 
     oldState.didComplete(completion, from: originalExecutor)
 
-    guard let handlers_ = handlers else {
+    switch completionResult {
+    case .completeEmpty:
+      // it is not safe to use release pool outside critical section.
+      // But at this point we have a guarantee that nobody else will use it
+      _releasePool.drain()
+      return true
+    case .complete(let handlers):
+      for handler in handlers {
+        handler.handle(completion, from: originalExecutor)
+      }
+      // it is not safe to use release pool outside critical section.
+      // But at this point we have a guarantee that nobody else will use it
+      _releasePool.drain()
+      return true
+    case .overcomplete:
       return false
     }
-
-    for handler in handlers_ {
-      handler.handle(completion, from: originalExecutor)
-    }
-
-    // it is not safe to use release pool outside critical section.
-    // But at this point we have a guarantee that nobody else will use it
-    _releasePool.drain()
-    return true
   }
 
   /// **internal use only**

    }
  }

  func complete(completion: Fallible<Success>) -> (PromiseState<Success>, [PromiseHandler<Success>]?) {
    switch self {
    case .initial:
      return (.completed(completion: completion), [])
    case let .subscribed(handlers):
      let unwrappedHandlers = handlers.value.flatMap { $0.value }
      return (.completed(completion: completion), unwrappedHandlers)
    case .completed:
      return (self, nil)
    }
  }


}

/// **internal use only**
private enum PromiseStateCompletionResult<Success> {
  case completeEmpty
  case complete([PromiseHandler<Success>])
  case overcomplete
}

/// **internal use only**
private enum PromiseState<Success> {
  case initial(notifyBlock: (_ isCompleted: Bool) -> Void)

  // mutable box to prevent unexpected copy on write
  case subscribed(handlers: MutableBox<[WeakBox<PromiseHandler<Success>>]>)
  case completed(completion: Fallible<Success>)

  var completion: Fallible<Success>? {
