Finish @nex3's strong-mode fixes in package:collection and test it in Travis

lib/src/unmodifiable_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.
 
 export "dart:collection" show UnmodifiableListView, UnmodifiableMapView;
 
 import 'wrappers.dart';
 
 /// A fixed-length list.
 ///
 /// A `NonGrowableListView` contains a [List] object and ensures that
 /// its length does not change.
 /// Methods that would change the length of the list,
 /// such as [add] and [remove], throw an [UnsupportedError].
 /// All other methods work directly on the underlying list.
 ///
 /// This class _does_ allow changes to the contents of the wrapped list.
 /// You can, for example, [sort] the list.
 /// Permitted operations defer to the wrapped list.
 class NonGrowableListView<E> extends DelegatingList<E>
                              with NonGrowableListMixin<E> {
   NonGrowableListView(List<E> listBase) : super(listBase);
 }
 
 /// Mixin class that implements a throwing version of all list operations that
 /// change the List's length.
 abstract class NonGrowableListMixin<E> implements List<E> {
-  static _throw() {
-    throw new UnsupportedError(
-        "Cannot change the length of a fixed-length list");
+  static final _error = new UnsupportedError(

[Leaf, 2016/03/18 16:35:40]

Another way to tackle this is to define 

 static /*=T*/ _throw/*<T>*/() { ...}

and then call it as

void set length(int newLength) => _throw();

inference will infer bottom for T, and it should all work out.

[ochafik, 2016/03/19 01:38:33]

Like it, thanks!

+      "Cannot change the length of a fixed-length list");
+
+  /// Throws an [UnsupportedError];
+  /// operations that change the length of the list are disallowed.
+  void set length(int newLength)  {
+    throw _error;
   }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  void set length(int newLength) => _throw();
+  bool add(E value)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  bool add(E value) => _throw();
+  void addAll(Iterable<E> iterable)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  void addAll(Iterable<E> iterable) => _throw();
+  void insert(int index, E element)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  void insert(int index, E element) => _throw();
+  void insertAll(int index, Iterable<E> iterable)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  void insertAll(int index, Iterable<E> iterable) => _throw();
+  bool remove(Object value)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  bool remove(Object value) => _throw();
+  E removeAt(int index)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  E removeAt(int index) => _throw();
+  E removeLast()  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  E removeLast() => _throw();
+  void removeWhere(bool test(E element))  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  void removeWhere(bool test(E element)) => _throw();
+  void retainWhere(bool test(E element))  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  void retainWhere(bool test(E element)) => _throw();
+  void removeRange(int start, int end)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  void removeRange(int start, int end) => _throw();
+  void replaceRange(int start, int end, Iterable<E> iterable)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the length of the list are disallowed.
-  void replaceRange(int start, int end, Iterable<E> iterable) => _throw();
-
-  /// Throws an [UnsupportedError];
-  /// operations that change the length of the list are disallowed.
-  void clear() => _throw();
+  void clear()  {
+    throw _error;
+  }
 }
 
 /// An unmodifiable set.
 ///
 /// An UnmodifiableSetView contains a [Set] object and ensures
 /// that it does not change.
 /// Methods that would change the set,
 /// such as [add] and [remove], throw an [UnsupportedError].
 /// Permitted operations defer to the wrapped set.
 class UnmodifiableSetView<E> extends DelegatingSet<E>
                              with UnmodifiableSetMixin<E> {
   UnmodifiableSetView(Set<E> setBase) : super(setBase);
 }
 
 /// Mixin class that implements a throwing version of all set operations that
 /// change the Set.
 abstract class UnmodifiableSetMixin<E> implements Set<E> {
-  _throw() {
-    throw new UnsupportedError("Cannot modify an unmodifiable Set");
+  static final _error =
+      new UnsupportedError("Cannot modify an unmodifiable Set");
+
+  /// Throws an [UnsupportedError];
+  /// operations that change the set are disallowed.
+  bool add(E value)  {
+    throw _error;
   }
 
   /// Throws an [UnsupportedError];
   /// operations that change the set are disallowed.
-  bool add(E value) => _throw();
+  void addAll(Iterable<E> elements)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the set are disallowed.
-  void addAll(Iterable<E> elements) => _throw();
+  bool remove(Object value)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the set are disallowed.
-  bool remove(Object value) => _throw();
+  void removeAll(Iterable elements)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the set are disallowed.
-  void removeAll(Iterable elements) => _throw();
+  void retainAll(Iterable elements)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the set are disallowed.
-  void retainAll(Iterable elements) => _throw();
+  void removeWhere(bool test(E element))  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the set are disallowed.
-  void removeWhere(bool test(E element)) => _throw();
+  void retainWhere(bool test(E element))  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the set are disallowed.
-  void retainWhere(bool test(E element)) => _throw();
-
-  /// Throws an [UnsupportedError];
-  /// operations that change the set are disallowed.
-  void clear() => _throw();
+  void clear()  {
+    throw _error;
+  }
 }
 
 /// Mixin class that implements a throwing version of all map operations that
 /// change the Map.
 abstract class UnmodifiableMapMixin<K, V> implements Map<K, V> {
-  static _throw() {
-    throw new UnsupportedError("Cannot modify an unmodifiable Map");
+  static final _error =
+      new UnsupportedError("Cannot modify an unmodifiable Map");
+
+  /// Throws an [UnsupportedError];
+  /// operations that change the map are disallowed.
+  void operator []=(K key, V value)  {
+    throw _error;
   }
 
   /// Throws an [UnsupportedError];
   /// operations that change the map are disallowed.
-  void operator []=(K key, V value) => _throw();
+  V putIfAbsent(K key, V ifAbsent())  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the map are disallowed.
-  V putIfAbsent(K key, V ifAbsent()) => _throw();
+  void addAll(Map<K, V> other)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the map are disallowed.
-  void addAll(Map<K, V> other) => _throw();
+  V remove(Object key)  {
+    throw _error;
+  }
 
   /// Throws an [UnsupportedError];
   /// operations that change the map are disallowed.
-  V remove(Object key) => _throw();
-
-  /// Throws an [UnsupportedError];
-  /// operations that change the map are disallowed.
-  void clear() => _throw();
+  void clear()  {
+    throw _error;
+  }
 }