Fix typo in method calls for [] and []= operators in views.

runtime/lib/typeddata.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.
 
 // patch classes for Int8List ..... Float64List and ByteData implementations.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
@@ skipping 1938 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getInt8(offsetInBytes +
-                              (index * Int8List.BYTES_PER_ELEMENT));
+    return _typeddata._getInt8(offsetInBytes +
+                               (index * Int8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setInt8(offsetInBytes + (index * Int8List.BYTES_PER_ELEMENT),
-                       _toInt8(value));
+    _typeddata. setInt8(offsetInBytes + (index * Int8List.BYTES_PER_ELEMENT),
+                        _toInt8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 15 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getUint8(offsetInBytes +
-                               (index * Uint8List.BYTES_PER_ELEMENT));
+    return _typeddata._getUint8(offsetInBytes +
+                                (index * Uint8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
-                        _toUint8(value));
+    _typeddata._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
+                         _toUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 16 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getUint8(offsetInBytes +
-                               (index * Uint8List.BYTES_PER_ELEMENT));
+    return _typeddata._getUint8(offsetInBytes +
+                                (index * Uint8List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
-                        _toClampedUint8(value));
+    _typeddata._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
+                         _toClampedUint8(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 15 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getInt16(offsetInBytes +
-                               (index * Int16List.BYTES_PER_ELEMENT));
+    return _typeddata._getInt16(offsetInBytes +
+                                (index * Int16List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setInt16(offsetInBytes + (index * Int16List.BYTES_PER_ELEMENT),
-                        _toInt16(value));
+    _typeddata._setInt16(offsetInBytes + (index * Int16List.BYTES_PER_ELEMENT),
+                         _toInt16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 15 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getUint16(offsetInBytes +
-                                (index * Uint16List.BYTES_PER_ELEMENT));
+    return _typeddata._getUint16(offsetInBytes +
+                                 (index * Uint16List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
-                         _toUint16(value));
+    _typeddata._setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
+                          _toUint16(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 15 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getInt32(offsetInBytes +
-                               (index * Int32List.BYTES_PER_ELEMENT));
+    return _typeddata._getInt32(offsetInBytes +
+                                (index * Int32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setInt32(offsetInBytes + (index * Int32List.BYTES_PER_ELEMENT),
-                        _toInt32(value));
+    _typeddata._setInt32(offsetInBytes + (index * Int32List.BYTES_PER_ELEMENT),
+                         _toInt32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 15 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getUint32(offsetInBytes +
-                                (index * Uint32List.BYTES_PER_ELEMENT));
+    return _typeddata._getUint32(offsetInBytes +
+                                 (index * Uint32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setUint32(offsetInBytes + (index * Uint32List.BYTES_PER_ELEMENT),
-                         _toUint32(value));
+    _typeddata._setUint32(offsetInBytes + (index * Uint32List.BYTES_PER_ELEMENT),
+                          _toUint32(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 15 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getInt64(offsetInBytes +
-                               (index * Int64List.BYTES_PER_ELEMENT));
+    return _typeddata._getInt64(offsetInBytes +
+                                (index * Int64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setInt64(offsetInBytes + (index * Int64List.BYTES_PER_ELEMENT),
-                        _toInt64(value));
+    _typeddata._setInt64(offsetInBytes + (index * Int64List.BYTES_PER_ELEMENT),
+                         _toInt64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 15 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getUint64(offsetInBytes +
-                                (index * Uint64List.BYTES_PER_ELEMENT));
+    return _typeddata._getUint64(offsetInBytes +
+                                 (index * Uint64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setUint64(offsetInBytes + (index * Uint64List.BYTES_PER_ELEMENT),
-                         _toUint64(value));
+    _typeddata._setUint64(offsetInBytes + (index * Uint64List.BYTES_PER_ELEMENT),
+                          _toUint64(value));
   }
 
   Iterator<int> get iterator {
     return new _TypedListIterator<int>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 15 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getFloat32(offsetInBytes +
-                                 (index * Float32List.BYTES_PER_ELEMENT));
+    return _typeddata._getFloat32(offsetInBytes +
+                                  (index * Float32List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setFloat32(offsetInBytes +
-                          (index * Float32List.BYTES_PER_ELEMENT), value);
+    _typeddata._setFloat32(offsetInBytes +
+                           (index * Float32List.BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
@@ skipping 15 matching lines @@
   }
 
 
   // Method(s) implementing List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    return _typeddata.getFloat64(offsetInBytes +
-                                 (index * Float64List.BYTES_PER_ELEMENT));
+    return _typeddata._getFloat64(offsetInBytes +
+                                  (index * Float64List.BYTES_PER_ELEMENT));
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       String message = "$index must be in the range [0..$length)";
       throw new RangeError(message);
     }
-    _typeddata.setFloat64(offsetInBytes +
+    _typeddata._setFloat64(offsetInBytes +
                           (index * Float64List.BYTES_PER_ELEMENT), value);
   }
 
   Iterator<double> get iterator {
     return new _TypedListIterator<double>(this);
   }
 
 
   // Method(s) implementing TypedData interface.
 
@@ skipping 171 matching lines @@
   }
 }
 
 
 int _defaultIfNull(object, value) {
   if (object == null) {
     return value;
   }
   return object;
 }