Fix strong mode warnings.

lib/src/queue_list.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 class that efficiently implements both [Queue] and [List].
 // TODO(nweiz): Currently this code is copied almost verbatim from
 // dart:collection. The only changes are to implement List and to remove methods
 // that are redundant with ListMixin. Remove or simplify it when issue 21330 is
@@ skipping 17 matching lines @@
     assert(_isPowerOf2(initialCapacity));
     _table = new List<E>(initialCapacity);
   }
 
   /// Create a queue initially containing the elements of [source].
   factory QueueList.from(Iterable<E> source) {
     if (source is List) {
       int length = source.length;
       QueueList<E> queue = new QueueList(length + 1);
       assert(queue._table.length > length);
-      List sourceList = source;
+      var sourceList = source;
       queue._table.setRange(0, length, sourceList, 0);
       queue._tail = length;
       return queue;
     } else {
       return new QueueList<E>()..addAll(source);
     }
   }
 
   // Collection interface.
 
   void add(E element) {
     _add(element);
   }
 
   void addAll(Iterable<E> elements) {
     if (elements is List) {
-      List list = elements;
+      var list = elements;
       int addCount = list.length;
       int length = this.length;
       if (length + addCount >= _table.length) {
         _preGrow(length + addCount);
         // After preGrow, all elements are at the start of the list.
         _table.setRange(length, length + addCount, list, 0);
         _tail += addCount;
       } else {
         // Adding addCount elements won't reach _head.
         int endSpace = _table.length - _tail;
@@ skipping 144 matching lines @@
     // Add 1.5x extra room to ensure that there's room for more elements after
     // expansion.
     newElementCount += newElementCount >> 1;
     int newCapacity = _nextPowerOf2(newElementCount);
     List<E> newTable = new List<E>(newCapacity);
     _tail = _writeToList(newTable);
     _table = newTable;
     _head = 0;
   }
 }