Fix all strong-mode warnings.

test/typed_buffers_test.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.
 
 // Tests typed-data buffer classes.
 
 import "dart:typed_data";
 
 import "package:test/test.dart";
 import "package:typed_data/typed_buffers.dart";
@@ skipping 134 matching lines @@
     }
   });
 }
 
 double roundToFloat(double value) {
   return (new Float32List(1)..[0] = value)[0];
 }
 
 typedef int Rounder(int value);
 
-Rounder roundUint(bits) {
+Rounder uintRounder(bits) {
   int halfbits = (1 << (bits ~/ 2)) - 1;
   int mask = halfbits | (halfbits << (bits ~/ 2));
   return (int x) => x & mask;
 }
 
-Rounder roundInt(bits) {
+Rounder intRounder(bits) {
   int highBit = 1 << (bits - 1);
   int mask = highBit - 1;
   return (int x) => (x & mask) - (x & highBit);
 }
 
 int clampUint8(x) => x < 0 ? 0 : x > 255 ? 255 : x;
 
-void testUint(int bits, var buffer, {String testOn}) {
+void testUint(int bits, buffer(int length), {String testOn}) {
   int min = 0;
-  Function round = roundUint(bits);
-  int max = round(-1);
+  var rounder = uintRounder(bits);
+  int max = rounder(-1);
   test("Uint${bits}Buffer", () {
-    testIntBuffer(bits, min, max, buffer, round);
+    testIntBuffer(bits, min, max, buffer, rounder);
   }, testOn: testOn);
 }
 
-void testInt(int bits, var buffer, {String testOn}) {
+void testInt(int bits, buffer(int length), {String testOn}) {
   int min = -(1 << (bits - 1));
   int max = -(min + 1);
   test("Int${bits}Buffer", () {
-    testIntBuffer(bits, min, max, buffer, roundInt(bits));
+    testIntBuffer(bits, min, max, buffer, intRounder(bits));
   }, testOn: testOn);
 }
 
 const List<int> intSamples = const [
   0x10000000000000001,
   0x10000000000000000,  // 2^64
   0x0ffffffffffffffff,
   0xaaaaaaaaaaaaaaaa,
   0x8000000000000001,
   0x8000000000000000,   // 2^63
@@ skipping 31 matching lines @@
 // Takes bit-size, min value, max value, function to create a buffer, and
 // the rounding that is applied when storing values outside the valid range
 // into the buffer.
 void testIntBuffer(int bits, int min, int max,
                    create(int length),
                    int round(int)) {
   assert(round(min) == min);
   assert(round(max) == max);
   // All int buffers default to the value 0.
   var buffer = create(0);
-  List<int> list = buffer;  // Check the type.
+  expect(buffer, new isInstanceOf<List<int>>());
   expect(buffer.length, equals(0));
   var bytes = bits ~/ 8;
 
   expect(buffer.elementSizeInBytes, equals(bytes));
   expect(buffer.lengthInBytes, equals(0));
   expect(buffer.offsetInBytes, equals(0));
 
   buffer.add(min);
   expect(buffer.length, equals(1));
   expect(buffer[0], equals(min));
@@ skipping 86 matching lines @@
   } else {
     if (x != y) {
     }
     expect(x, equals(y));
   }
 }
 
 testFloatBuffer(int bitSize, List samples, create(), double round(double v)) {
   test("Float${bitSize}Buffer", () {
     var buffer = create();
-    List<double> list = buffer;  // Test type.
+    expect(buffer, new isInstanceOf<List<double>>());
     int byteSize = bitSize ~/ 8;
 
     expect(buffer.length, equals(0));
     buffer.add(0.0);
     expect(buffer.length, equals(1));
     expect(buffer.removeLast(), equals(0.0));
     expect(buffer.length, equals(0));
 
     for (double value in samples) {
       buffer.add(value);
@@ skipping 34 matching lines @@
       int tmp = bytes[i];
       bytes[i] = bytes[byteSize + i];
       bytes[byteSize + i] = tmp;
     }
     doubleEqual(buffer[0], round(samples[1]));
     doubleEqual(buffer[1], round(samples[0]));
   });
 }
 
 testFloat32x4Buffer(List floatSamples) {
-  List float4Samples = [];
+  var float4Samples = <Float32x4>[];
   for (int i = 0; i < floatSamples.length - 3; i++) {
     float4Samples.add(new Float32x4(floatSamples[i],
                                     floatSamples[i + 1],
                                     floatSamples[i + 2],
                                     floatSamples[i + 3]));
   }
 
   void floatEquals(x, y) {
     if (y.isNaN) {
       expect(x.isNaN, isTrue);
     } else {
       expect(x, equals(y));
     }
   }
 
   void x4Equals(Float32x4 x, Float32x4 y) {
     floatEquals(x.x, y.x);
     floatEquals(x.y, y.y);
     floatEquals(x.z, y.z);
     floatEquals(x.w, y.w);
   }
 
   test("Float32x4Buffer", () {
     var buffer = new Float32x4Buffer(5);
-    List<Float32x4> list = buffer;
+    expect(buffer, new isInstanceOf<List<Float32x4>>());
 
     expect(buffer.length, equals(5));
     expect(buffer.elementSizeInBytes, equals(128 ~/ 8));
     expect(buffer.lengthInBytes, equals(5 * 128 ~/ 8));
     expect(buffer.offsetInBytes, equals(0));
 
     x4Equals(buffer[0], new Float32x4.zero());
     buffer.length = 0;
     expect(buffer.length, equals(0));
 
@@ skipping 19 matching lines @@
     buffer[0] = float4Samples[0];  // Does not contain NaN.
 
     Float32List floats = new Float32List.view(buffer.buffer);
     expect(floats[0], equals(buffer[0].x));
     expect(floats[1], equals(buffer[0].y));
     expect(floats[2], equals(buffer[0].z));
     expect(floats[3], equals(buffer[0].w));
   });
 }
 
-void testInt32x4Buffer(intSamples) {
+void testInt32x4Buffer(List<int> intSamples) {
   test("Int32x4Buffer", () {
-    Function round = roundInt(32);
-    int bits = 128;
+    Function rounder = intRounder(32);
     int bytes = 128 ~/ 8;
     Matcher equals32x4(Int32x4 expected) => new MatchesInt32x4(expected);
 
     var buffer = new Int32x4Buffer(0);
-    List<Int32x4> list = buffer;     // It's a List.
+    expect(buffer, new isInstanceOf<List<Int32x4>>());
     expect(buffer.length, equals(0));
 
     expect(buffer.elementSizeInBytes, equals(bytes));
     expect(buffer.lengthInBytes, equals(0));
     expect(buffer.offsetInBytes, equals(0));
 
     Int32x4 sample = new Int32x4(-0x80000000, -1, 0, 0x7fffffff);
     buffer.add(sample);
     expect(buffer.length, equals(1));
     expect(buffer[0], equals32x4(sample));
 
     expect(buffer.elementSizeInBytes, equals(bytes));
     expect(buffer.lengthInBytes, equals(bytes));
     expect(buffer.offsetInBytes, equals(0));
 
     buffer.length = 0;
     expect(buffer.length, equals(0));
 
     var samples = intSamples
-        .where((value) => value == round(value))   // Issue 15130
+        .where((value) => value == rounder(value))   // Issue 15130
         .map((value) => new Int32x4(value, -value, ~value, ~-value))
         .toList();
     for (Int32x4 value in samples) {
       int length = buffer.length;
       buffer.add(value);
       expect(buffer.length, equals(length + 1));
       expect(buffer[length], equals32x4(value));
     }
 
     buffer.addAll(samples);  // Add all the values at once.
@@ skipping 26 matching lines @@
   bool matches(item, Map matchState) {
     if (item is! Int32x4) return false;
     Int32x4 value = item;
     return result.x == value.x && result.y == value.y &&
            result.z == value.z && result.w == value.w;
   }
 
   Description describe(Description description) =>
       description.add('Int32x4.==');
 }