Add "last" setter to List.

pkg/collection/lib/wrappers.dart

 // Copyright (c) 2013, 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.
 
 /**
  * Delegating wrappers for [Iterable], [List], [Set], [Queue] and [Map].
  *
  * Also adds unmodifiable views for `Set` and `Map`, and a fixed length
  * view for `List`. The unmodifable list view from `dart:collection` is exported
  * as well, just for completeness.
@@ skipping 106 matching lines @@
   const DelegatingList(List<E> base) : super(base);
 
   List<E> get _listBase => _base;
 
   E operator [](int index) => _listBase[index];
 
   void operator []=(int index, E value) {
     _listBase[index] = value;
   }
 
+  void set last(E value) {
+    _listBase.last = value;

[nweiz, 2014/06/12 23:03:58]

This will cause an analyzer warning on versions of the SDK that don't support
[List.last=] in the core libraries. It may be a good idea to increase the SDK
constraint in the pubspec to avoid that.

+  }
+
   void add(E value) {
     _listBase.add(value);
   }
 
   void addAll(Iterable<E> iterable) {
     _listBase.addAll(iterable);
   }
 
   Map<int, E> asMap() => _listBase.asMap();
 
@@ skipping 283 matching lines @@
    * the elements of [other].
    *
    * Note that the returned set will use the default equality operation, which
    * may be different than the equality operation [this] uses.
    */
   Set<E> union(Set<E> other) => toSet()..addAll(other);
 }
 
 /**
  * Creates a modifiable [Set] view of the values of a [Map].
- * 
+ *
  * The `Set` view assumes that the keys of the `Map` can be uniquely determined
  * from the values. The `keyForValue` function passed to the constructor finds
  * the key for a single value. The `keyForValue` function should be consistent
  * with equality. If `value1 == value2` then `keyForValue(value1)` and
  * `keyForValue(value2)` should be considered equal keys by the underlying map,
  * and vice versa.
  *
  * Modifying the set will modify the underlying map based on the key returned by
  * `keyForValue`.
  *
@@ skipping 119 matching lines @@
    * Returns a new set which contains all the elements of [this] and [other].
    *
    * That is, the returned set contains all the elements of this [Set] and all
    * the elements of [other].
    *
    * Note that the returned set will use the default equality operation, which
    * may be different than the equality operation [this] uses.
    */
   Set<V> union(Set<V> other) => toSet()..addAll(other);
 }