- Remove redundant type parameters for internal data.

lib/growable_array.dart

 // Copyright (c) 2012, 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.
 
 class _GrowableObjectArray<T> implements List<T> {
   factory _GrowableObjectArray._uninstantiable() {
     throw new UnsupportedError(
         "GrowableObjectArray can only be allocated by the VM");
   }
 
   T removeAt(int index) {
     if (index is! int) throw new ArgumentError(index);
     T result = this[index];

[siva, 2013/02/08 23:13:34]

can this just be:
var result = this[index];
(the type check will happen on the return statement).

[Ivan Posva, 2013/02/08 23:27:32]

Agree with you that we should rip out ALL of the types inside the methods here,
like it is suggested for good Dart code. But that should be a different change.

     int newLength = this.length - 1;
     Arrays.copy(this,
                 index + 1,
                 this,
                 index,
                 newLength - index);
     this.length = newLength;
     return result;
   }
 
@@ skipping 68 matching lines @@
   List<T> getRange(int start, int length) {
     if (length == 0) return [];
     Arrays.rangeCheck(this, start, length);
     List list = new _GrowableObjectArray<T>.withCapacity(length);
     list.length = length;
     Arrays.copy(this, start, list, 0, length);
     return list;
   }
 
   factory _GrowableObjectArray(int length) {
-    var data = new _ObjectArray<T>((length == 0) ? 4 : length);
+    var data = new _ObjectArray((length == 0) ? 4 : length);
     var result = new _GrowableObjectArray<T>.withData(data);
     result._setLength(length);
     return result;
   }
 
   factory _GrowableObjectArray.withCapacity(int capacity) {
-    var data = new _ObjectArray<T>((capacity == 0)? 4 : capacity);
+    var data = new _ObjectArray((capacity == 0)? 4 : capacity);
     return new _GrowableObjectArray<T>.withData(data);
   }
 
   factory _GrowableObjectArray.from(Collection<T> other) {
     List<T> result = new _GrowableObjectArray<T>();

[siva, 2013/02/08 23:13:34]

var result = new ...
just like how it is done in factory _GrowableObjectArray

[Ivan Posva, 2013/02/08 23:27:32]

Again, as above the removal of types in the bodies is a different CL.

     result.addAll(other);
     return result;
   }
 
-  factory _GrowableObjectArray.withData(_ObjectArray<T> data)
+  factory _GrowableObjectArray.withData(_ObjectArray data)
     native "GrowableObjectArray_allocate";
 
   int get length native "GrowableObjectArray_getLength";
 
   int get _capacity native "GrowableObjectArray_getCapacity";
 
   void set length(int new_length) {
     if (new_length > _capacity) {
       _grow(new_length);
     } else {
       for (int i = new_length; i < length; i++) {
         this[i] = null;
       }
     }
     _setLength(new_length);
   }
 
   void _setLength(int new_length) native "GrowableObjectArray_setLength";
 
-  void _setData(_ObjectArray<T> array) native "GrowableObjectArray_setData";
+  void _setData(_ObjectArray array) native "GrowableObjectArray_setData";
 
   T operator [](int index) native "GrowableObjectArray_getIndexed";
 
   void operator []=(int index, T value) native "GrowableObjectArray_setIndexed";
 
   // The length of this growable array. It is always less than or equal to the
   // length of the object array, which itself is always greater than 0, so that
   // grow() does not have to check for a zero length object array before
   // doubling its size.
   void add(T value) {
@@ skipping 46 matching lines @@
   int indexOf(T element, [int start = 0]) {
     return Arrays.indexOf(this, element, start, length);
   }
 
   int lastIndexOf(T element, [int start = null]) {
     if (start == null) start = length - 1;
     return Arrays.lastIndexOf(this, element, start);
   }
 
   void _grow(int new_length) {
-    var new_data = new _ObjectArray<T>(new_length);
+    var new_data = new _ObjectArray(new_length);
     for (int i = 0; i < length; i++) {
       new_data[i] = this[i];
     }
     _setData(new_data);
   }
 
   // Collection interface.
 
   bool contains(T element) {
     return IterableMixinWorkaround.contains(this, element);
@@ skipping 108 matching lines @@
   }
 
   List<T> toList() {
     return new List<T>.from(this);
   }
 
   Set<T> toSet() {
     return new Set<T>.from(this);
   }
 }