Fix some warnings in the core library identified by the static analyzer.

runtime/tests/vm/dart/byte_array_test.dart

 class ByteArrayTest {
   static testInt8List() {
     Expect.throws(() { new Int8List(-1); },
                   (e) { return e is IllegalArgumentException; });
     var array = new Int8List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(10, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
@@ skipping 906 matching lines @@
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(12, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int8List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int8List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int8List.view(array.asByteArray(),
-                                          array.length); },
+                                         array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int8List.view(array.asByteArray(),
-                                          0, array.length + 1); },
+                                         0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int8List.view(array.asByteArray(),
-                                          array.length - 1, 2); },
+                                         array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Int8List.view(array.asByteArray(),
+                                  array.lengthInBytes());
+    Expect.isTrue(empty is List<int>);
+    Expect.isTrue(empty is Int8List);
+    Expect.equals(0, empty.length);
+    var whole = new Int8List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Int8List);
+    Expect.equals(12, whole.length);
     var view = new Int8List.view(array.asByteArray(), 1, array.length - 2);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int8List);
     Expect.equals(10, view.length);
     Expect.equals(1, view.bytesPerElement());
     Expect.equals(10, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 91 matching lines @@
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(12, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint8List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(),
-                                           array.length); },
+                                          array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(),
-                                           0, array.length + 1); },
+                                          0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(),
-                                           array.length - 1, 2); },
+                                          array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Uint8List.view(array.asByteArray(),
+                                   array.lengthInBytes());
+    Expect.isTrue(empty is List<int>);
+    Expect.isTrue(empty is Uint8List);
+    Expect.equals(0, empty.length);
+    var whole = new Uint8List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Uint8List);
+    Expect.equals(12, whole.length);
     var view = new Uint8List.view(array.asByteArray(), 1, array.length - 2);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint8List);
     Expect.equals(10, view.length);
     Expect.equals(1, view.bytesPerElement());
     Expect.equals(10, view.lengthInBytes());
     Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                        0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 70 matching lines @@
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(24, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int16List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int16List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int16List.view(array.asByteArray(),
-                                           array.length); },
+                                          array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int16List.view(array.asByteArray(),
                                            0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int16List.view(array.asByteArray(),
                                            array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Int16List.view(array.asByteArray(),
+                                   array.lengthInBytes());
+    Expect.isTrue(empty is List<int>);
+    Expect.isTrue(empty is Int16List);
+    Expect.equals(0, empty.length);
+    var whole = new Int16List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Int16List);
+    Expect.equals(12, whole.length);
     var view = new Int16List.view(array.asByteArray(), 2, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int16List);
     Expect.equals(10, view.length);
     Expect.equals(2, view.bytesPerElement());
     Expect.equals(20, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 98 matching lines @@
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(24, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint16List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(),
-                                            array.length); },
+                                           array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(),
-                                            0, array.length + 1); },
+                                           0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(),
-                                            array.length - 1, 2); },
+                                           array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Uint16List.view(array.asByteArray(),
+                                    array.lengthInBytes());
+    Expect.isTrue(empty is List<int>);
+    Expect.isTrue(empty is Uint16List);
+    Expect.equals(0, empty.length);
+    var whole = new Uint16List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Uint16List);
+    Expect.equals(12, whole.length);
     var view = new Uint16List.view(array.asByteArray(), 2, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint16List);
     Expect.equals(10, view.length);
     Expect.equals(2, view.bytesPerElement());
     Expect.equals(20, view.lengthInBytes());
     Expect.listEquals([0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
                        0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 75 matching lines @@
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(48, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int32List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int32List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int32List.view(array.asByteArray(),
-                                           array.length); },
+                                          array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int32List.view(array.asByteArray(),
-                                           0, array.length + 1); },
+                                          0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int32List.view(array.asByteArray(),
-                                           array.length - 1, 2); },
+                                          array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Int32List.view(array.asByteArray(),
+                                   array.lengthInBytes());
+    Expect.isTrue(empty is List<int>);
+    Expect.isTrue(empty is Int32List);
+    Expect.equals(0, empty.length);
+    var whole = new Int32List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Int32List);
+    Expect.equals(12, whole.length);
     var view = new Int32List.view(array.asByteArray(), 4, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int32List);
     Expect.equals(10, view.length);
     Expect.equals(4, view.bytesPerElement());
     Expect.equals(40, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 122 matching lines @@
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(48, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint32List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(),
-                                            array.length); },
+                                           array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(),
-                                            0, array.length + 1); },
+                                           0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(),
-                                            array.length - 1, 2); },
+                                           array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Uint32List.view(array.asByteArray(),
+                                    array.lengthInBytes());
+    Expect.isTrue(empty is List<int>);
+    Expect.isTrue(empty is Uint32List);
+    Expect.equals(0, empty.length);
+    var whole = new Uint32List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Uint32List);
+    Expect.equals(12, whole.length);
     var view = new Uint32List.view(array.asByteArray(), 4, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint32List);
     Expect.equals(10, view.length);
     Expect.equals(4, view.bytesPerElement());
     Expect.equals(40, view.lengthInBytes());
     Expect.listEquals([0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
                        0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 92 matching lines @@
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(96, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xFF;
     }
     Expect.throws(() { new Int64List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int64List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int64List.view(array.asByteArray(),
-                                           array.length); },
+                                          array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int64List.view(array.asByteArray(),
-                                           0, array.length + 1); },
+                                          0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int64List.view(array.asByteArray(),
-                                           array.length - 1, 2); },
+                                          array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Int64List.view(array.asByteArray(),
+                                   array.lengthInBytes());
+    Expect.isTrue(empty is List<int>);
+    Expect.isTrue(empty is Int64List);
+    Expect.equals(0, empty.length);
+    var whole = new Int64List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Int64List);
+    Expect.equals(12, whole.length);
     var view = new Int64List.view(array.asByteArray(), 8, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int64List);
     Expect.equals(10, view.length);
     Expect.equals(8, view.bytesPerElement());
     Expect.equals(80, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 159 matching lines @@
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(96, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = -1;
     }
     Expect.throws(() { new Uint64List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(),
-                                            array.length); },
+                                           array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(),
-                                            0, array.length + 1); },
+                                           0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(),
-                                            array.length - 1, 2); },
+                                           array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Uint64List.view(array.asByteArray(),
+                                    array.lengthInBytes());
+    Expect.isTrue(empty is List<int>);
+    Expect.isTrue(empty is Uint64List);
+    Expect.equals(0, empty.length);
+    var whole = new Uint64List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Uint64List);
+    Expect.equals(12, whole.length);
     var view = new Uint64List.view(array.asByteArray(), 8, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint64List);
     Expect.equals(10, view.length);
     Expect.equals(8, view.bytesPerElement());
     Expect.equals(80, view.lengthInBytes());
     Expect.listEquals([0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
@@ skipping 120 matching lines @@
     Expect.equals(4, array.bytesPerElement());
     Expect.equals(48, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xBF800000;
     }
     Expect.throws(() { new Float32List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float32List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float32List.view(array.asByteArray(),
-                                             array.lengthInBytes() + 1); },
+                                            array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float32List.view(array.asByteArray(),
-                                             0, array.lengthInBytes() + 1); },
+                                            0, array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float32List.view(array.asByteArray(),
-                                             array.lengthInBytes() - 1, 2); },
+                                            array.lengthInBytes() - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Float32List.view(array.asByteArray(),
+                                     array.lengthInBytes());
+    Expect.isTrue(empty is List<double>);
+    Expect.isTrue(empty is Float32List);
+    Expect.equals(0, empty.length);
+    var whole = new Float32List.view(array.asByteArray());
+    Expect.isTrue(whole is List<double>);
+    Expect.isTrue(whole is Float32List);
+    Expect.equals(12, whole.length);
     var view = new Float32List.view(array.asByteArray(), 4, 10);
     Expect.isTrue(view is List<double>);
+    Expect.isTrue(view is Float32List);
     Expect.equals(10, view.length);
     Expect.equals(4, view.bytesPerElement());
     Expect.equals(40, view.lengthInBytes());
     Expect.listEquals([-1.0, -1.0, -1.0, -1.0, -1.0,
                        -1.0, -1.0, -1.0, -1.0, -1.0],
                       view);
     Expect.throws(() { view[-1] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
@@ skipping 63 matching lines @@
     Expect.equals(8, array.bytesPerElement());
     Expect.equals(96, array.lengthInBytes());
     for (int i = 0; i < array.length; ++i) {
       array[i] = 0xBFF0000000000000;
     }
     Expect.throws(() { new Float64List.view(array.asByteArray(), -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float64List.view(array.asByteArray(), 0, -1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float64List.view(array.asByteArray(),
-                                             array.lengthInBytes() + 1); },
+                                            array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float64List.view(array.asByteArray(),
-                                             0, array.lengthInBytes() + 1); },
+                                            0, array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float64List.view(array.asByteArray(),
-                                             array.lengthInBytes() - 1, 2); },
+                                            array.lengthInBytes() - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var empty = new Float64List.view(array.asByteArray(),
+                                     array.lengthInBytes());
+    Expect.isTrue(empty is List<double>);
+    Expect.isTrue(empty is Float64List);
+    Expect.equals(0, empty.length);
+    var whole = new Float64List.view(array.asByteArray());
+    Expect.isTrue(whole is List<double>);
+    Expect.isTrue(whole is Float64List);
+    Expect.equals(12, whole.length);
     var view = new Float64List.view(array.asByteArray(), 8, 10);
     Expect.isTrue(view is List<double>);
+    Expect.isTrue(view is Float64List);
     Expect.equals(10, view.length);
     Expect.equals(8, view.bytesPerElement());
     Expect.equals(80, view.lengthInBytes());
     Expect.listEquals([-1.0, -1.0, -1.0, -1.0, -1.0,
                        -1.0, -1.0, -1.0, -1.0, -1.0],
                       view);
     Expect.throws(() { view[-1] = 0.0; },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
@@ skipping 77 matching lines @@
     testInt64ListView();
     testUint64ListView();
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   ByteArrayTest.testMain();
 }