Fix strong mode warnings.

lib/src/priority_queue.dart

 // Copyright (c) 2014, 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:collection";
 
 /// A priority queue is a priority based work-list of elements.
 ///
 /// The queue allows adding elements, and removing them again in priority order.
 abstract class PriorityQueue<E> {
   /// Creates an empty [PriorityQueue].
   ///
   /// The created [PriorityQueue] is a plain [HeapPriorityQueue].
   ///
   /// The [comparison] is a [Comparator] used to compare the priority of
   /// elements. An element that compares as less than another element has
   /// a higher priority.
   ///
-  /// If [comparison] is omitted, it defaults to [Comparable.compare].
+  /// If [comparison] is omitted, it defaults to [Comparable.compare]. If this
+  /// is the case, `E` must implement [Comparable], and this is checked at
+  /// runtime for every comparison.
   factory PriorityQueue([int comparison(E e1, E e2)]) = HeapPriorityQueue<E>;
 
   /// Number of elements in the queue.
   int get length;
 
   /// Whether the queue is empty.
   bool get isEmpty;
 
   /// Whether the queue has any elements.
   bool get isNotEmpty;
@@ skipping 84 matching lines @@
 ///   an expected O(n*log(n)) time.
 class HeapPriorityQueue<E> implements PriorityQueue<E> {
   /// Initial capacity of a queue when created, or when added to after a
   /// [clear].
   ///
   /// Number can be any positive value. Picking a size that gives a whole
   /// number of "tree levels" in the heap is only done for aesthetic reasons.
   static const int _INITIAL_CAPACITY = 7;
 
   /// The comparison being used to compare the priority of elements.
-  final Comparator comparison;
+  final Comparator<E> comparison;
 
   /// List implementation of a heap.
   List<E> _queue = new List<E>(_INITIAL_CAPACITY);
 
   /// Number of elements in queue.
   ///
   /// The heap is implemented in the first [_length] entries of [_queue].
   int _length = 0;
 
   /// Create a new priority queue.
   ///
   /// The [comparison] is a [Comparator] used to compare the priority of
   /// elements. An element that compares as less than another element has
   /// a higher priority.
   ///
-  /// If [comparison] is omitted, it defaults to [Comparable.compare].
+  /// If [comparison] is omitted, it defaults to [Comparable.compare]. If this
+  /// is the case, `E` must implement [Comparable], and this is checked at
+  /// runtime for every comparison.
   HeapPriorityQueue([int comparison(E e1, E e2)])
-      : comparison = (comparison != null) ? comparison : Comparable.compare;
+      : comparison = comparison ??
+            ((e1, e2) => (e1 as Comparable).compareTo(e2));
 
   void add(E element) {
     _add(element);
   }
 
   void addAll(Iterable<E> elements) {
     for (E element in elements) {
       _add(element);
     }
   }
@@ skipping 192 matching lines @@
   ///
   /// Called when the list is full.
   void _grow() {
     int newCapacity = _queue.length * 2 + 1;
     if (newCapacity < _INITIAL_CAPACITY) newCapacity = _INITIAL_CAPACITY;
     List<E> newQueue = new List<E>(newCapacity);
     newQueue.setRange(0, _length, _queue);
     _queue = newQueue;
   }
 }