Try reducing code size for _prependListeners.

sdk/lib/async/future_impl.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.async;
 
 /** The onValue and onError handlers return either a value or a future */
 typedef dynamic _FutureOnValue<T>(T value);
 /** Test used by [Future.catchError] to handle skip some errors. */
 typedef bool _FutureErrorTest(var error);
@@ skipping 222 matching lines @@
     _state = _PENDING_COMPLETE;
   }
 
   AsyncError get _error {
     assert(_hasError);
     return _resultOrListeners;
   }
 
   _Future get _chainSource {
     assert(_isChained);
-    return _resultOrListeners;
+    _Future result = _resultOrListeners;
+    while (result._isChained) {
+      result = result._resultOrListeners;
+      _resultOrListeners = result;
+    }
+    return result;
   }
 
   // This method is used by async/await.
   void _setValue(T value) {
     assert(!_isComplete);  // But may have a completion pending.
     _state = _VALUE;
     _resultOrListeners = value;
   }
 
   void _setErrorObject(AsyncError error) {
@@ skipping 15 matching lines @@
     _state = source._state;
     _resultOrListeners = source._resultOrListeners;
   }
 
   void _addListener(_FutureListener listener) {
     assert(listener._nextListener == null);
     if (_mayAddListener) {
       listener._nextListener = _resultOrListeners;
       _resultOrListeners = listener;
     } else {
-      if (_isChained) {
-        // Delegate listeners to chained source future.
-        // If the source is complete, instead copy its values and
-        // drop the chaining.
-        _Future source = _chainSource;
-        if (!source._isComplete) {
-          source._addListener(listener);
-          return;
-        }
-        _cloneResult(source);
-      }
-      assert(_isComplete);
-      // Handle late listeners asynchronously.
-      _zone.scheduleMicrotask(() {
-        _propagateToListeners(this, listener);
-      });
+      _handleListener(listener);
     }
   }
 
+  void _handleListener(_FutureListener listener) {
+    assert(listener._nextListener == null);
+    assert(!_mayAddListener);
+    if (_isChained) {
+      _Future source = _chainSource;
+      // Delegate listeners to chained source future.
+      // If the source is complete, instead copy its values and
+      // drop the chaining.
+      if (!source._isComplete) {
+        source._addListener(listener);
+        return;
+      }
+      _cloneResult(source);
+    }
+    assert(_isComplete);
+    // Handle late listeners asynchronously.
+    _zone.scheduleMicrotask(() {
+      _propagateToListeners(this, listener);
+    });
+  }
+
   void _prependListeners(_FutureListener listeners) {
-    if (listeners == null) return;
-    if (_mayAddListener) {
-      _FutureListener existingListeners = _resultOrListeners;
-      _resultOrListeners = listeners;
-      if (existingListeners != null) {
-        _FutureListener cursor = listeners;
-        while (cursor._nextListener != null) {
-          cursor = cursor._nextListener;
-        }
-        cursor._nextListener = existingListeners;
-      }
-    } else {
-      if (_isChained) {
-        // Delegate listeners to chained source future.
-        // If the source is complete, instead copy its values and
-        // drop the chaining.
-        _Future source = _chainSource;
-        if (!source._isComplete) {
-          source._prependListeners(listeners);
-          return;
-        }
-        _cloneResult(source);
-      }
-      assert(_isComplete);
-      listeners = _reverseListeners(listeners);
-      _zone.scheduleMicrotask(() {
-        _propagateToListeners(this, listeners);
-      });
+    while (listeners != null) {
+      _FutureListener first = listeners;
+      listeners = listeners._nextListener;
+      first._nextListener = null;
+      _addListener(first);
     }
   }
 
   _FutureListener _removeListeners() {
     // Reverse listeners before returning them, so the resulting list is in
     // subscription order.
     assert(!_isComplete);
     _FutureListener current = _resultOrListeners;
     _resultOrListeners = null;
-    return _reverseListeners(current);
-  }
-
-  _FutureListener _reverseListeners(_FutureListener listeners) {
     _FutureListener prev = null;
-    _FutureListener current = listeners;
     while (current != null) {
       _FutureListener next = current._nextListener;
       current._nextListener = prev;
       prev = current;
       current = next;
     }
     return prev;
   }
 
   // Take the value (when completed) of source and complete target with that
@@ skipping 30 matching lines @@
     }
   }
 
   // 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._mayAddListener);  // Not completed, not already chained.
     while (source._isChained) {
       source = source._chainSource;
     }
+    _FutureListener listeners = target._removeListeners();
     if (source._isComplete) {
-      _FutureListener listeners = target._removeListeners();
       target._cloneResult(source);
       _propagateToListeners(target, listeners);
     } else {
-      _FutureListener listeners = target._resultOrListeners;
       target._setChained(source);
       source._prependListeners(listeners);
     }
   }
 
   void _complete(value) {
     assert(!_isComplete);
     if (value is Future) {
       if (value is _Future) {
         _chainCoreFuture(value, this);
@@ skipping 299 matching lines @@
       }
     }, onError: (e, s) {
       if (timer.isActive) {
         timer.cancel();
         result._completeError(e, s);
       }
     });
     return result;
   }
 }