anchor.diff:    // Take the value (when completed) of source and complete target with that
     // value (or error). This function expects that source is a _Future.
     static void _chainCoreFuture(_Future source, _Future target) {
  -    assert(!target._isComplete);
  -    assert(source is _Future);
  -
  -    // Mark the target as chained (and as such half-completed).
  -    target._setChained();
  -    _FutureListener listener = new _FutureListener.chain(target);
  +    assert(target._mayAddListener);  // Not completed, not already chained.
  +    while (source._isChained) {
  +      source = source._chainSource;
  +    }
       if (source._isComplete) {
  -      _propagateToListeners(source, listener);
  +      _FutureListener listeners = target._removeListeners();
  +      target._cloneResult(source);
  +      _propagateToListeners(target, listeners);
       } else {
  -      source._addListener(listener);
  +      _FutureListener listeners = target._resultOrListeners;
  +      target._setChained(source);
  +      source._prependListeners(listeners);
       }
     }
   
  
positive.code: 
    bool get _mayComplete       => _state == _INCOMPLETE;
    bool get _isPendingComplete => _state == _PENDING_COMPLETE;
    bool get _isChained         => _state == _CHAINED;
    bool get _isComplete        => _state >= _VALUE;
    bool get _hasValue          => _state == _VALUE;
    bool get _hasError          => _state == _ERROR;
  
    void _setChained() {
      assert(!_isComplete);
      _state = _CHAINED;
    }
  
    Future then(f(T value), { Function onError }) {
  
negative.code:         _propagateToListeners(source, listener);
        }
        _FutureListener listener = listeners;
        final sourceResult = source._resultOrListeners;
        // Do the actual propagation.
        // Set initial state of listenerHasError and listenerValueOrError. These
        // variables are updated with the outcome of potential callbacks.
        // Non-error results, including futures, are stored in
        // listenerValueOrError and listenerHasError is set to false. Errors
        // are stored in listenerValueOrError as an [AsyncError] and
        // listenerHasError is set to true.
        bool listenerHasError = hasError;
        var listenerValueOrError = sourceResult;
  
        // Only if we either have an error or callbacks, go into this, somewhat
  