 
   /// Returns either completion for complete `Promise` or nil otherwise
   override public var completion: Fallible<Success>? {
-    return _locking.locker(self) { $0._completion }
+    _locking.lock()
+    defer { _locking.unlock() }
+    return _completion
   }
 
   private var _completion: Fallible<Success>? {


  /// **internal use only**
  override public func _asyncNinja_retainUntilFinalization(_ releasable: Releasable) {
    _locking.locker(self, releasable) { (self_, releasable) -> Void in
      if !self_._isComplete {
        self_._releasePool.insert(releasable)
      }
    }
  }

  /// **internal use only**
  override public func _asyncNinja_notifyFinalization(_ block: @escaping () -> Void) {
    let shouldCallBlockNow = _locking.locker(self, block) { (self_, block) -> Bool in
      if self_._isComplete {
        return true
      } else {
        self_._releasePool.notifyDrain(block)
        return false
      }
    }

    if shouldCallBlockNow {
      block()

    from originalExecutor: Executor? = nil
    ) -> Bool {

    _locking.lock()
    let oldState = _state
    let (newState, completionResult) = oldState.complete(completion: completion)
    _state = newState
    _locking.unlock()

    oldState.didComplete(completion, from: originalExecutor)

