Fix all strong-mode warnings.

lib/typed_buffers.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.
 
 /// Growable typed-data lists.
 ///
 /// These lists works just as a typed-data list, except that they are growable.
 /// They use an underlying buffer, and when that buffer becomes too small, it
 /// is replaced by a new buffer.
 ///
 /// That means that using the [TypedDataView.buffer] getter is not guaranteed
 /// to return the same result each time it is used, and that the buffer may
 /// be larger than what the list is using.
 library dart.pkg.typed_data.typed_buffers;
 
 import "dart:collection" show ListBase;
 import "dart:typed_data";
 
 abstract class _TypedDataBuffer<E> extends ListBase<E> {
   static const int INITIAL_LENGTH = 8;
 
-  /// This is a Uint8List for Uint8Buffer. It's both a List<E> and a TypedData,
-  /// which we don't have a type for here.
-  var _buffer;
+  /// The underlying data buffer.
+  ///
+  /// This is always both a List<E> and a TypedData, which we don't have a type
+  /// for here. For example, for a `Uint8Buffer`, this is a `Uint8List`.
+  List<E> _buffer;
+
+  /// Returns a view of [_buffer] as a [TypedData].
+  TypedData get _typedBuffer => _buffer as TypedData;
+
   /// The length of the list being built.
   int _length;
 
   _TypedDataBuffer(List<E> buffer)
-      : this._buffer = buffer, this._length = buffer.length;
+      : this._buffer = buffer,
+        this._length = buffer.length;
 
   int get length => _length;
   E operator[](int index) {
     if (index >= length) throw new RangeError.index(index, this);
     return _buffer[index];
   }
 
   void operator[]=(int index, E value) {
     if (index >= length) throw new RangeError.index(index, this);
     _buffer[index] = value;
@@ skipping 107 matching lines @@
 
     // Swap [index.._length) and [_length..writeIndex) by double-reversing.
     _reverse(_buffer, index, _length);
     _reverse(_buffer, _length, writeIndex);
     _reverse(_buffer, index, writeIndex);
     _length = writeIndex;
     return;
   }
 
   // Reverses the range [start..end) of buffer.
-  static void _reverse(List<int> buffer, int start, int end) {
+  static void _reverse(List buffer, int start, int end) {
     end--;  // Point to last element, not after last element.
     while (start < end) {
       var first = buffer[start];
       var last = buffer[end];
       buffer[end] = first;
       buffer[start] = last;
       start++;
       end--;
     }
   }
@@ skipping 104 matching lines @@
   void _setRange(int start, int end, Iterable<E> source, int skipCount) {
     if (source is _TypedDataBuffer<E>) {
       _buffer.setRange(start, end, source._buffer, skipCount);
     } else {
       _buffer.setRange(start, end, source, skipCount);
     }
   }
 
   // TypedData.
 
-  int get elementSizeInBytes => _buffer.elementSizeInBytes;
+  int get elementSizeInBytes => _typedBuffer.elementSizeInBytes;
 
-  int get lengthInBytes => _length * _buffer.elementSizeInBytes;
+  int get lengthInBytes => _length * _typedBuffer.elementSizeInBytes;
 
-  int get offsetInBytes => _buffer.offsetInBytes;
+  int get offsetInBytes => _typedBuffer.offsetInBytes;
 
   /// Returns the underlying [ByteBuffer].
   ///
   /// The returned buffer may be replaced by operations that change the [length]
   /// of this list.
   ///
   /// The buffer may be larger than [lengthInBytes] bytes, but never smaller.
-  ByteBuffer get buffer => _buffer.buffer;
+  ByteBuffer get buffer => _typedBuffer.buffer;
 
   // Specialization for the specific type.
 
   // Return zero for integers, 0.0 for floats, etc.
   // Used to fill buffer when changing length.
   E get _defaultValue;
 
   // Create a new typed list to use as buffer.
   List<E> _createBuffer(int size);
 }
 
 abstract class _IntBuffer extends _TypedDataBuffer<int> {
-  _IntBuffer(buffer): super(buffer);
+  _IntBuffer(List<int> buffer): super(buffer);
+
   int get _defaultValue => 0;
 }
 
 abstract class _FloatBuffer extends _TypedDataBuffer<double> {
-  _FloatBuffer(buffer): super(buffer);
+  _FloatBuffer(List<double> buffer): super(buffer);
+
   double get _defaultValue => 0.0;
 }
 
 class Uint8Buffer extends _IntBuffer {
   Uint8Buffer([int initialLength = 0]) : super(new Uint8List(initialLength));
   Uint8List _createBuffer(int size) => new Uint8List(size);
 }
 
 class Int8Buffer extends _IntBuffer {
   Int8Buffer([int initialLength = 0]) : super(new Int8List(initialLength));
@@ skipping 55 matching lines @@
   Int32x4 get _defaultValue => _zero;
   Int32x4List _createBuffer(int size) => new Int32x4List(size);
 }
 
 class Float32x4Buffer extends _TypedDataBuffer<Float32x4> {
   Float32x4Buffer([int initialLength = 0])
       : super(new Float32x4List(initialLength));
   Float32x4 get _defaultValue => new Float32x4.zero();
   Float32x4List _createBuffer(int size) => new Float32x4List(size);
 }