Fix strong mode warnings.

lib/src/algorithms.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.
 
 import "dart:math" as math;
 
 /// Version of [binarySearch] optimized for comparable keys
-int _comparableBinarySearch(List<Comparable> list, Comparable value) {
+int _comparableBinarySearch/*<T extends Comparable<T>>*/(
+    List<Comparable/*<T>*/> list, Comparable/*<T>*/ value) {
   int min = 0;
   int max = list.length;
   while (min < max) {
     int mid = min + ((max - min) >> 1);
     var element = list[mid];
     int comp = element.compareTo(value);
     if (comp == 0) return mid;
     if (comp < 0) {
       min = mid + 1;
     } else {
       max = mid;
     }
   }
   return -1;
 }
 
 /// Returns a position of the [value] in [sortedList], if it is there.
 ///
 /// If the list isn't sorted according to the [compare] function, the result
 /// is unpredictable.
 ///
 /// If [compare] is omitted, it defaults to calling [Comparable.compareTo] on
 /// the objects.
 ///
 /// Returns -1 if [value] is not in the list by default.
-int binarySearch(List sortedList, value, { int compare(a, b) }) {
+int binarySearch/*<T extends Comparable<T>>*/(
+    List/*<T>*/ sortedList, /*=T*/ value, { int compare(/*=T*/ a, /*=T*/ b) }) {
   if (compare == null) {
     return _comparableBinarySearch(sortedList, value);
   }
   int min = 0;
   int max = sortedList.length;
   while (min < max) {
     int mid = min + ((max - min) >> 1);
     var element = sortedList[mid];
     int comp = compare(element, value);
     if (comp == 0) return mid;
@@ skipping 27 matching lines @@
 /// [value].
 ///
 /// If the list isn't sorted according to the [compare] function, the result
 /// is unpredictable.
 ///
 /// If [compare] is omitted, it defaults to calling [Comparable.compareTo] on
 /// the objects.
 ///
 /// Returns [sortedList.length] if all the items in [sortedList] compare less
 /// than [value].
-int lowerBound(List sortedList, value, { int compare(a, b) }) {
+int lowerBound/*<T extends Comparable<T>>*/(

[abarth, 2016/03/26 07:13:23]

This change isn't correct.  The arguments to this function don't need to extend
Comparable<T>.  That's why the function takes a compare function.

+    List/*<T>*/ sortedList, /*=T*/ value, { int compare(/*=T*/ a, /*=T*/ b) }) {
   if (compare == null) {
     return _comparableLowerBound(sortedList, value);
   }
   int min = 0;
   int max = sortedList.length;
   while (min < max) {
     int mid = min + ((max - min) >> 1);
     var element = sortedList[mid];
     int comp = compare(element, value);
     if (comp < 0) {
@@ skipping 221 matching lines @@
       target.setRange(targetOffset, targetOffset + (firstEnd - cursor1),
           firstList, cursor1);
       return;
     }
   }
   // First list empties first. Reached by break above.
   target[targetOffset++] = secondElement;
   target.setRange(targetOffset, targetOffset + (secondEnd - cursor2),
       secondList, cursor2);
 }