Simplify the VM's typed_data constructors.

runtime/lib/typed_data.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.
 
 import "dart:_internal";
 import 'dart:math' show Random;
 
 patch class Int8List {
@@ skipping 909 matching lines @@
       _setUint16(byteStart + i * Uint16List.BYTES_PER_ELEMENT,
                  string.codeUnitAt(skipCount + i));
     }
   }
 }
 
 
 class _Int8Array extends _TypedList with _IntListMixin implements Int8List {
   // Factory constructors.
 
-  factory _Int8Array(int length) {
-    return _new(length);
-  }
-
+  factory _Int8Array(int length) native "TypedData_Int8Array_new";
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getInt8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setInt8(index, _toInt8(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int8Array _createList(int length) {
-    return _new(length);
+    return new _Int8Array(length);
   }
-
-  static _Int8Array _new(int length) native "TypedData_Int8Array_new";
 }
 
 
 class _Uint8Array extends _TypedList with _IntListMixin implements Uint8List {
   // Factory constructors.
 
-  factory _Uint8Array(int length) {
-    return _new(length);
-  }
-
+  factory _Uint8Array(int length) native "TypedData_Uint8Array_new";
 
   // Methods implementing List interface.
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setUint8(index, _toUint8(value));
   }
 
 
   // Methods implementing TypedData interface.
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint8Array _createList(int length) {
-    return _new(length);
+    return new _Uint8Array(length);
   }
-
-  static _Uint8Array _new(int length) native "TypedData_Uint8Array_new";
 }
 
 
 class _Uint8ClampedArray extends _TypedList with _IntListMixin implements Uint8ClampedList {
   // Factory constructors.
 
-  factory _Uint8ClampedArray(int length) {
-    return _new(length);
-  }
+  factory _Uint8ClampedArray(int length) native "TypedData_Uint8ClampedArray_new";
 
   // Methods implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setUint8(index, _toClampedUint8(value));
   }
 
 
   // Methods implementing TypedData interface.
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint8ClampedArray _createList(int length) {
-    return _new(length);
+    return new _Uint8ClampedArray(length);
   }
-
-  static _Uint8ClampedArray _new(int length)
-      native "TypedData_Uint8ClampedArray_new";
 }
 
 
 class _Int16Array extends _TypedList with _IntListMixin implements Int16List {
   // Factory constructors.
 
-  factory _Int16Array(int length) {
-    return _new(length);
-  }
-
+  factory _Int16Array(int length) native "TypedData_Int16Array_new";
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedInt16(index);
   }
 
@@ skipping 18 matching lines @@
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int16Array _createList(int length) {
-    return _new(length);
+    return new _Int16Array(length);
   }
 
   int _getIndexedInt16(int index) {
     return _getInt16(index * Int16List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt16(int index, int value) {
     _setInt16(index * Int16List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Int16Array _new(int length) native "TypedData_Int16Array_new";
 }
 
 
 class _Uint16Array extends _TypedList with _IntListMixin implements Uint16List {
   // Factory constructors.
 
-  factory _Uint16Array(int length) {
-    return _new(length);
-  }
-
+  factory _Uint16Array(int length) native "TypedData_Uint16Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedUint16(index);
   }
 
@@ skipping 18 matching lines @@
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint16Array _createList(int length) {
-    return _new(length);
+    return new _Uint16Array(length);
   }
 
   int _getIndexedUint16(int index) {
     return _getUint16(index * Uint16List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint16(int index, int value) {
     _setUint16(index * Uint16List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Uint16Array _new(int length) native "TypedData_Uint16Array_new";
 }
 
 
 class _Int32Array extends _TypedList with _IntListMixin implements Int32List {
   // Factory constructors.
 
-  factory _Int32Array(int length) {
-    return _new(length);
-  }
-
+  factory _Int32Array(int length) native "TypedData_Int32Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedInt32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setIndexedInt32(index, _toInt32(value));
   }
 
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int32Array _createList(int length) {
-    return _new(length);
+    return new _Int32Array(length);
   }
 
   int _getIndexedInt32(int index) {
     return _getInt32(index * Int32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt32(int index, int value) {
     _setInt32(index * Int32List.BYTES_PER_ELEMENT, value);
   }
 
-  static _Int32Array _new(int length) native "TypedData_Int32Array_new";
 }
 
 
 class _Uint32Array extends _TypedList with _IntListMixin implements Uint32List {
   // Factory constructors.
 
-  factory _Uint32Array(int length) {
-    return _new(length);
-  }
-
+  factory _Uint32Array(int length) native "TypedData_Uint32Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedUint32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setIndexedUint32(index, _toUint32(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint32Array _createList(int length) {
-    return _new(length);
+    return new _Uint32Array(length);
   }
 
   int _getIndexedUint32(int index) {
     return _getUint32(index * Uint32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint32(int index, int value) {
     _setUint32(index * Uint32List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Uint32Array _new(int length) native "TypedData_Uint32Array_new";
 }
 
 
 class _Int64Array extends _TypedList with _IntListMixin implements Int64List {
   // Factory constructors.
 
-  factory _Int64Array(int length) {
-    return _new(length);
-  }
-
+  factory _Int64Array(int length) native "TypedData_Int64Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedInt64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setIndexedInt64(index, _toInt64(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int64Array _createList(int length) {
-    return _new(length);
+    return new _Int64Array(length);
   }
 
   int _getIndexedInt64(int index) {
     return _getInt64(index * Int64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt64(int index, int value) {
     _setInt64(index * Int64List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Int64Array _new(int length) native "TypedData_Int64Array_new";
 }
 
 
 class _Uint64Array extends _TypedList with _IntListMixin implements Uint64List {
   // Factory constructors.
 
-  factory _Uint64Array(int length) {
-    return _new(length);
-  }
-
+  factory _Uint64Array(int length) native "TypedData_Uint64Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedUint64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setIndexedUint64(index, _toUint64(value));
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint64Array _createList(int length) {
-    return _new(length);
+    return new _Uint64Array(length);
   }
 
   int _getIndexedUint64(int index) {
     return _getUint64(index * Uint64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint64(int index, int value) {
     _setUint64(index * Uint64List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Uint64Array _new(int length) native "TypedData_Uint64Array_new";
 }
 
 
 class _Float32Array extends _TypedList with _DoubleListMixin implements Float32List {
   // Factory constructors.
 
-  factory _Float32Array(int length) {
-    return _new(length);
-  }
-
+  factory _Float32Array(int length) native "TypedData_Float32Array_new";
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedFloat32(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setIndexedFloat32(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float32Array _createList(int length) {
-    return _new(length);
+    return new _Float32Array(length);
   }
 
   double _getIndexedFloat32(int index) {
     return _getFloat32(index * Float32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat32(int index, double value) {
     _setFloat32(index * Float32List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Float32Array _new(int length) native "TypedData_Float32Array_new";
 }
 
 
 class _Float64Array extends _TypedList with _DoubleListMixin implements Float64List {
   // Factory constructors.
 
-  factory _Float64Array(int length) {
-    return _new(length);
-  }
-
+  factory _Float64Array(int length) native "TypedData_Float64Array_new";
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedFloat64(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setIndexedFloat64(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float64Array _createList(int length) {
-    return _new(length);
+    return new _Float64Array(length);
   }
 
   double _getIndexedFloat64(int index) {
     return _getFloat64(index * Float64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat64(int index, double value) {
     _setFloat64(index * Float64List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Float64Array _new(int length) native "TypedData_Float64Array_new";
 }
 
 
 class _Float32x4Array extends _TypedList with _Float32x4ListMixin implements Float32x4List {
   // Factory constructors.
 
-  factory _Float32x4Array(int length) {
-    return _new(length);
-  }
-
+  factory _Float32x4Array(int length) native "TypedData_Float32x4Array_new";
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedFloat32x4(index);
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setIndexedFloat32x4(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float32x4Array _createList(int length) {
-    return _new(length);
+    return new _Float32x4Array(length);
   }
 
   Float32x4 _getIndexedFloat32x4(int index) {
     return _getFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat32x4(int index, Float32x4 value) {
     _setFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Float32x4Array _new(int length) native "TypedData_Float32x4Array_new";
 }
 
 
 class _Int32x4Array extends _TypedList with _Int32x4ListMixin implements Int32x4List {
   // Factory constructors.
 
-  factory _Int32x4Array(int length) {
-    return _new(length);
-  }
-
+  factory _Int32x4Array(int length) native "TypedData_Int32x4Array_new";
 
   Int32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedInt32x4(index);
   }
 
   void operator[]=(int index, Int32x4 value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setIndexedInt32x4(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int32x4Array _createList(int length) {
-    return _new(length);
+    return new _Int32x4Array(length);
   }
 
   Int32x4 _getIndexedInt32x4(int index) {
     return _getInt32x4(index * Int32x4List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt32x4(int index, Int32x4 value) {
     _setInt32x4(index * Int32x4List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Int32x4Array _new(int length) native "TypedData_Int32x4Array_new";
 }
 
 
 class _Float64x2Array extends _TypedList with _Float64x2ListMixin implements Float64x2List {
   // Factory constructors.
 
-  factory _Float64x2Array(int length) {
-    return _new(length);
-  }
-
+  factory _Float64x2Array(int length) native "TypedData_Float64x2Array_new";
 
   Float64x2 operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedFloat64x2(index);
   }
 
   void operator[]=(int index, Float64x2 value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setIndexedFloat64x2(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float64x2Array _createList(int length) {
-    return _new(length);
+    return new _Float64x2Array(length);
   }
 
   Float64x2 _getIndexedFloat64x2(int index) {
     return _getFloat64x2(index * Float64x2List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat64x2(int index, Float64x2 value) {
     _setFloat64x2(index * Float64x2List.BYTES_PER_ELEMENT, value);
   }
-
-  static _Float64x2Array _new(int length) native "TypedData_Float64x2Array_new";
 }
 
 
 class _ExternalInt8Array extends _TypedList with _IntListMixin implements Int8List {
   // Factory constructors.
 
-  factory _ExternalInt8Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalInt8Array(int length) native "ExternalTypedData_Int8Array_new";
 
   // Method(s) implementing the List interface.
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getInt8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     _setInt8(index, value);
   }
 
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int8List _createList(int length) {
     return new Int8List(length);
   }
-
-  static _ExternalInt8Array _new(int length) native
-      "ExternalTypedData_Int8Array_new";
 }
 
 
 class _ExternalUint8Array extends _TypedList with _IntListMixin implements Uint8List {
   // Factory constructors.
 
-  factory _ExternalUint8Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalUint8Array(int length) native "ExternalTypedData_Uint8Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getUint8(index);
   }
 
@@ skipping 10 matching lines @@
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint8List _createList(int length) {
     return new Uint8List(length);
   }
-
-  static _ExternalUint8Array _new(int length) native
-      "ExternalTypedData_Uint8Array_new";
 }
 
 
 class _ExternalUint8ClampedArray extends _TypedList with _IntListMixin implements Uint8ClampedList {
   // Factory constructors.
 
-  factory _ExternalUint8ClampedArray(int length) {
-    return _new(length);
-  }
+  factory _ExternalUint8ClampedArray(int length) native "ExternalTypedData_Uint8ClampedArray_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getUint8(index);
   }
 
@@ skipping 10 matching lines @@
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint8ClampedList _createList(int length) {
     return new Uint8ClampedList(length);
   }
-
-  static _ExternalUint8ClampedArray _new(int length) native
-      "ExternalTypedData_Uint8ClampedArray_new";
 }
 
 
 class _ExternalInt16Array extends _TypedList with _IntListMixin implements Int16List {
   // Factory constructors.
 
-  factory _ExternalInt16Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalInt16Array(int length) native "ExternalTypedData_Int16Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedInt16(index);
   }
 
@@ skipping 18 matching lines @@
     return new Int16List(length);
   }
 
   int _getIndexedInt16(int index) {
     return _getInt16(index * Int16List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt16(int index, int value) {
     _setInt16(index * Int16List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalInt16Array _new(int length) native
-      "ExternalTypedData_Int16Array_new";
 }
 
 
 class _ExternalUint16Array extends _TypedList with _IntListMixin implements Uint16List {
   // Factory constructors.
 
-  factory _ExternalUint16Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalUint16Array(int length) native "ExternalTypedData_Uint16Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedUint16(index);
   }
 
@@ skipping 18 matching lines @@
     return new Uint16List(length);
   }
 
   int _getIndexedUint16(int index) {
     return _getUint16(index * Uint16List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint16(int index, int value) {
     _setUint16(index * Uint16List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalUint16Array _new(int length) native
-      "ExternalTypedData_Uint16Array_new";
 }
 
 
 class _ExternalInt32Array extends _TypedList with _IntListMixin implements Int32List {
   // Factory constructors.
 
-  factory _ExternalInt32Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalInt32Array(int length) native "ExternalTypedData_Int32Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedInt32(index);
   }
 
@@ skipping 18 matching lines @@
     return new Int32List(length);
   }
 
   int _getIndexedInt32(int index) {
     return _getInt32(index * Int32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt32(int index, int value) {
     _setInt32(index * Int32List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalInt32Array _new(int length) native
-      "ExternalTypedData_Int32Array_new";
 }
 
 
 class _ExternalUint32Array extends _TypedList with _IntListMixin implements Uint32List {
   // Factory constructors.
 
-  factory _ExternalUint32Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalUint32Array(int length) native "ExternalTypedData_Uint32Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedUint32(index);
   }
 
@@ skipping 18 matching lines @@
     return new Uint32List(length);
   }
 
   int _getIndexedUint32(int index) {
     return _getUint32(index * Uint32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint32(int index, int value) {
     _setUint32(index * Uint32List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalUint32Array _new(int length) native
-      "ExternalTypedData_Uint32Array_new";
 }
 
 
 class _ExternalInt64Array extends _TypedList with _IntListMixin implements Int64List {
   // Factory constructors.
 
-  factory _ExternalInt64Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalInt64Array(int length) native "ExternalTypedData_Int64Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedInt64(index);
   }
 
@@ skipping 18 matching lines @@
     return new Int64List(length);
   }
 
   int _getIndexedInt64(int index) {
     return _getInt64(index * Int64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt64(int index, int value) {
     _setInt64(index * Int64List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalInt64Array _new(int length) native
-      "ExternalTypedData_Int64Array_new";
 }
 
 
 class _ExternalUint64Array extends _TypedList with _IntListMixin implements Uint64List {
   // Factory constructors.
 
-  factory _ExternalUint64Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalUint64Array(int length) native "ExternalTypedData_Uint64Array_new";
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedUint64(index);
   }
 
@@ skipping 18 matching lines @@
     return new Uint64List(length);
   }
 
   int _getIndexedUint64(int index) {
     return _getUint64(index * Uint64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint64(int index, int value) {
     _setUint64(index * Uint64List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalUint64Array _new(int length) native
-      "ExternalTypedData_Uint64Array_new";
 }
 
 
 class _ExternalFloat32Array extends _TypedList with _DoubleListMixin implements Float32List {
   // Factory constructors.
 
-  factory _ExternalFloat32Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalFloat32Array(int length) native "ExternalTypedData_Float32Array_new";
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedFloat32(index);
   }
 
@@ skipping 18 matching lines @@
     return new Float32List(length);
   }
 
   double _getIndexedFloat32(int index) {
     return _getFloat32(index * Float32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat32(int index, double value) {
     _setFloat32(index * Float32List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalFloat32Array _new(int length) native
-      "ExternalTypedData_Float32Array_new";
 }
 
 
 class _ExternalFloat64Array extends _TypedList with _DoubleListMixin implements Float64List {
   // Factory constructors.
 
-  factory _ExternalFloat64Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalFloat64Array(int length) native "ExternalTypedData_Float64Array_new";
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedFloat64(index);
   }
 
@@ skipping 18 matching lines @@
     return new Float64List(length);
   }
 
   double _getIndexedFloat64(int index) {
     return _getFloat64(index * Float64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat64(int index, double value) {
     _setFloat64(index * Float64List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalFloat64Array _new(int length) native
-      "ExternalTypedData_Float64Array_new";
 }
 
 
 class _ExternalFloat32x4Array extends _TypedList with _Float32x4ListMixin implements Float32x4List {
   // Factory constructors.
 
-  factory _ExternalFloat32x4Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalFloat32x4Array(int length) native "ExternalTypedData_Float32x4Array_new";
 
   // Method(s) implementing the List interface.
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedFloat32x4(index);
   }
 
@@ skipping 18 matching lines @@
     return new Float32x4List(length);
   }
 
   Float32x4 _getIndexedFloat32x4(int index) {
     return _getFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat32x4(int index, Float32x4 value) {
     _setFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalFloat32x4Array _new(int length) native
-      "ExternalTypedData_Float32x4Array_new";
 }
 
 
 class _ExternalInt32x4Array extends _TypedList with _Int32x4ListMixin implements Int32x4List {
   // Factory constructors.
 
-  factory _ExternalInt32x4Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalInt32x4Array(int length) native "ExternalTypedData_Int32x4Array_new";
 
   // Method(s) implementing the List interface.
 
   Int32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedInt32x4(index);
   }
 
@@ skipping 18 matching lines @@
     return new Int32x4List(length);
   }
 
   Int32x4 _getIndexedInt32x4(int index) {
     return _getInt32x4(index * Int32x4List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt32x4(int index, Int32x4 value) {
     _setInt32x4(index * Int32x4List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalInt32x4Array _new(int length) native
-      "ExternalTypedData_Int32x4Array_new";
 }
 
 
 class _ExternalFloat64x2Array extends _TypedList with _Float64x2ListMixin implements Float64x2List {
   // Factory constructors.
 
-  factory _ExternalFloat64x2Array(int length) {
-    return _new(length);
-  }
-
+  factory _ExternalFloat64x2Array(int length) native "ExternalTypedData_Float64x2Array_new";
 
   // Method(s) implementing the List interface.
 
   Float64x2 operator[](int index) {
     if (index < 0 || index >= length) {
       throw new RangeError.index(index, this, "index");
     }
     return _getIndexedFloat64x2(index);
   }
 
@@ skipping 18 matching lines @@
     return new Float64x2List(length);
   }
 
   Float64x2 _getIndexedFloat64x2(int index) {
     return _getFloat64x2(index * Float64x2List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat64x2(int index, Float64x2 value) {
     _setFloat64x2(index * Float64x2List.BYTES_PER_ELEMENT, value);
   }
-
-  static _ExternalFloat64x2Array _new(int length) native
-      "ExternalTypedData_Float64x2Array_new";
 }
 
 
 class _Float32x4 implements Float32x4 {
   factory _Float32x4(double x, double y, double z, double w)
       native "Float32x4_fromDoubles";
   factory _Float32x4.splat(double v) native "Float32x4_splat";
   factory _Float32x4.zero() native "Float32x4_zero";
   factory _Float32x4.fromInt32x4Bits(Int32x4 x)
       native "Float32x4_fromInt32x4Bits";
@@ skipping 1299 matching lines @@
   }
 }
 
 
 int _defaultIfNull(object, value) {
   if (object == null) {
     return value;
   }
   return object;
 }