 		/// method as a result of a false positive `terminating` check is permitted.
 		///
 		/// - precondition: `stateLock` must not be acquired by the caller.
-		///
-		/// - returns: `.shouldDispose` if the attempt succeeds. `.none` otherwise.
-		private func tryToCommitTermination() -> OperationResult {
+		private func tryToCommitTermination() {
 			// Acquire `stateLock`. If the termination has still not yet been
 			// handled, take it over and bump the status to `terminated`.
 			stateLock.lock()

				let observer = newObservers.remove(using: token)
				self.state = .alive(newObservers, hasDeinitialized: hasDeinitialized)

				var result = OperationResult.none

				// Ensure `observer` is deallocated after `stateLock` is
				// released to avoid deadlocks.
				withExtendedLifetime(observer) {
					// Start the disposal of the `Signal` core if the `Signal` has
					// deinitialized and there is no active observer.
					result = tryToDisposeSilentlyIfQualified()

					stateLock.unlock()
				}

				if result == .shouldTryCommitTermination {
					result = tryToCommitTermination()
				}

				if result == .shouldDispose {
					// Disposing of `disposable` is assumed to remove the generator
					// observer from its attached `Signal`, so that the generator observer
					// as the last +1 retain of the `Signal` core may deinitialize.
					disposable.dispose()
				}
			} else {
				stateLock.unlock()

				} else {
					self.stateLock.unlock()
				}

				tryToCommitTermination()
			} else {
				self.sendLock.lock()
				self.stateLock.lock()
