anchor.diff:      var completer = Completer<T?>.sync();
       value.then(completer.complete, onError: completer.completeError);
   
  -    _completer._cancelCompleter.future.then((_) {
  +    _completer._cancelCompleter?.future.then((_) {
         completer.complete(cancellationValue);
       }, onError: completer.completeError);
   
  
positive.code:   /// The completer can be cancelled until the result becomes available,
    /// even if [isCompleted] is true.
    Future<void> _cancel() {
      if (_inner.isCompleted) return Future.value(null);
  
      if (!_isCanceled) {
        _isCanceled = true;
        var onCancel = _onCancel;
        _cancelCompleter
            .complete(onCancel == null ? null : Future.sync(onCancel));
      }
      return _cancelCompleter.future;
    }
  }
  
negative.code:   /// has been called once.
    /// The [isCompleted] is true when either of these methods have been called.
    void complete([FutureOr<T>? value]) {
      if (!_mayComplete) throw StateError('Operation already completed');
      _mayComplete = false;
  
      if (value is! Future<T>) {
        _completeNow()?.complete(value);
        return;
      }
  
      if (_inner == null) {
        // Make sure errors from [value] aren't top-leveled.
        value.ignore();
        return;
      }
  
      value.then((result) {
        _completeNow()?.complete(result);
      }, onError: (Object error, StackTrace stackTrace) {
        _completeNow()?.completeError(error, stackTrace);
      });
    }
  
    /// Completer to use for completing with a result.
    ///
    /// Returns `null` if it's not possible to complete any more.
    /// Sets [_cancelCompleter] to `null` if returning non-`null`.
    Completer<T>? _completeNow() {
      var inner = _inner;
      if (inner == null) return null;
      _cancelCompleter = null;
      return inner;
    }
  
    /// Completes [operation] with [error] and [stackTrace].
  