SkipIterable - ensure field is only initialized to a known int.

sdk/lib/internal/iterable.dart

 // Copyright (c) 2011, 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.
 
 part of dart._internal;
 
 /**
  * Marker interface for [Iterable] subclasses that have an efficient
  * [length] implementation.
  */
@@ skipping 566 matching lines @@
 }
 
 class SkipIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   final int _skipCount;
 
   factory SkipIterable(Iterable<E> iterable, int count) {
     if (iterable is EfficientLengthIterable) {
       return new EfficientLengthSkipIterable<E>(iterable, count);
     }
-    return new SkipIterable<E>._(iterable, count);
+    return new SkipIterable<E>._(iterable, _checkCount(count));
   }
 
-  SkipIterable._(this._iterable, this._skipCount) {
-    if (_skipCount is! int) {
-      throw new ArgumentError.value(_skipCount, "count is not an integer");
-    }
-    RangeError.checkNotNegative(_skipCount, "count");
-  }
+  SkipIterable._(this._iterable, this._skipCount);
 
   Iterable<E> skip(int count) {
-    if (_skipCount is! int) {
-      throw new ArgumentError.value(_skipCount, "count is not an integer");
-    }
-    RangeError.checkNotNegative(_skipCount, "count");
-    return new SkipIterable<E>._(_iterable, _skipCount + count);
+    return new SkipIterable<E>._(_iterable, _skipCount + _checkCount(count));
   }
 
   Iterator<E> get iterator {
     return new SkipIterator<E>(_iterable.iterator, _skipCount);
   }
 }
 
 class EfficientLengthSkipIterable<E> extends SkipIterable<E>
     implements EfficientLengthIterable<E> {
-  EfficientLengthSkipIterable(Iterable<E> iterable, int skipCount)
-      : super._(iterable, skipCount);
+  factory EfficientLengthSkipIterable(Iterable<E> iterable, int count) {
+    return new EfficientLengthSkipIterable<E>._(iterable, _checkCount(count));
+  }
+
+  EfficientLengthSkipIterable._(Iterable<E> iterable, int count)
+      : super._(iterable, count);
 
   int get length {
     int length = _iterable.length - _skipCount;
     if (length >= 0) return length;
     return 0;
   }
+
+  Iterable<E> skip(int count) {
+    return new EfficientLengthSkipIterable<E>._(
+        _iterable, _skipCount + _checkCount(count));
+  }
+}
+
+int _checkCount(int count) {
+  if (count is! int) {
+    throw new ArgumentError.value(count, "count", "is not an integer");
+  }
+  RangeError.checkNotNegative(count, "count");
+  return count;
 }
 
 class SkipIterator<E> extends Iterator<E> {
   final Iterator<E> _iterator;
   int _skipCount;
 
   SkipIterator(this._iterator, this._skipCount) {
     assert(_skipCount is int && _skipCount >= 0);
   }
 
@@ skipping 132 matching lines @@
  * Creates errors throw by [Iterable] when the element count is wrong.
  */
 abstract class IterableElementError {
   /** Error thrown thrown by, e.g., [Iterable.first] when there is no result. */
   static StateError noElement() => new StateError("No element");
   /** Error thrown by, e.g., [Iterable.single] if there are too many results. */
   static StateError tooMany() => new StateError("Too many elements");
   /** Error thrown by, e.g., [List.setRange] if there are too few elements. */
   static StateError tooFew() => new StateError("Too few elements");
 }