Big merge from experimental to bleeding edge.

sdk/lib/utf/utf16.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.
 
 part of dart.utf;
 
 /**
  * Decodes the UTF-16 bytes as an iterable. Thus, the consumer can only convert
  * as much of the input as needed. Determines the byte order from the BOM,
  * or uses big-endian as a default. This method always strips a leading BOM.
@@ skipping 95 matching lines @@
 List<int> encodeUtf16(String str) =>
     encodeUtf16be(str, true);
 
 /**
  * Produce a list of UTF-16BE encoded bytes. By default, this method produces
  * UTF-16BE bytes with no BOM.
  */
 List<int> encodeUtf16be(String str, [bool writeBOM = false]) {
   List<int> utf16CodeUnits = _stringToUtf16CodeUnits(str);
   List<int> encoding =
-      new List<int>(2 * utf16CodeUnits.length + (writeBOM ? 2 : 0));
+      new List<int>.fixedLength(2 * utf16CodeUnits.length + (writeBOM ? 2 : 0));
   int i = 0;
   if (writeBOM) {
     encoding[i++] = UNICODE_UTF_BOM_HI;
     encoding[i++] = UNICODE_UTF_BOM_LO;
   }
   for (int unit in utf16CodeUnits) {
     encoding[i++] = (unit & UNICODE_BYTE_ONE_MASK) >> 8;
     encoding[i++] = unit & UNICODE_BYTE_ZERO_MASK;
   }
   return encoding;
 }
 
 /**
  * Produce a list of UTF-16LE encoded bytes. By default, this method produces
  * UTF-16LE bytes with no BOM.
  */
 List<int> encodeUtf16le(String str, [bool writeBOM = false]) {
   List<int> utf16CodeUnits = _stringToUtf16CodeUnits(str);
   List<int> encoding =
-      new List<int>(2 * utf16CodeUnits.length + (writeBOM ? 2 : 0));
+      new List<int>.fixedLength(2 * utf16CodeUnits.length + (writeBOM ? 2 : 0));
   int i = 0;
   if (writeBOM) {
     encoding[i++] = UNICODE_UTF_BOM_LO;
     encoding[i++] = UNICODE_UTF_BOM_HI;
   }
   for (int unit in utf16CodeUnits) {
     encoding[i++] = unit & UNICODE_BYTE_ZERO_MASK;
     encoding[i++] = (unit & UNICODE_BYTE_ONE_MASK) >> 8;
   }
   return encoding;
@@ skipping 34 matching lines @@
   return _codepointsToUtf16CodeUnits(str.charCodes);
 }
 
 typedef _ListRangeIterator _CodeUnitsProvider();
 
 /**
  * Return type of [decodeUtf16AsIterable] and variants. The Iterable type
  * provides an iterator on demand and the iterator will only translate bytes
  * as requested by the user of the iterator. (Note: results are not cached.)
  */
-class IterableUtf16Decoder implements Iterable<int> {
+// TODO(floitsch): Consider removing the extend and switch to implements since
+// that's cheaper to allocate.
+class IterableUtf16Decoder extends Iterable<int> {
   final _CodeUnitsProvider codeunitsProvider;
   final int replacementCodepoint;
 
   IterableUtf16Decoder._(this.codeunitsProvider, this.replacementCodepoint);
 
-  Utf16CodeUnitDecoder iterator() =>
+  Utf16CodeUnitDecoder get iterator =>
       new Utf16CodeUnitDecoder.fromListRangeIterator(codeunitsProvider(),
           replacementCodepoint);
 }
 
 /**
  * Convert UTF-16 encoded bytes to UTF-16 code units by grouping 1-2 bytes
  * to produce the code unit (0-(2^16)-1). Relies on BOM to determine
  * endian-ness, and defaults to BE.
  */
 class Utf16BytesToCodeUnitsDecoder implements _ListRangeIterator {
   final _ListRangeIterator utf16EncodedBytesIterator;
   final int replacementCodepoint;
+  int _current = null;
 
   Utf16BytesToCodeUnitsDecoder._fromListRangeIterator(
       this.utf16EncodedBytesIterator, this.replacementCodepoint);
 
   factory Utf16BytesToCodeUnitsDecoder(List<int> utf16EncodedBytes, [
       int offset = 0, int length,
       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
     if (length == null) {
       length = utf16EncodedBytes.length - offset;
     }
     if (hasUtf16beBom(utf16EncodedBytes, offset, length)) {
       return new Utf16beBytesToCodeUnitsDecoder(utf16EncodedBytes, offset + 2,
           length - 2, false, replacementCodepoint);
     } else if (hasUtf16leBom(utf16EncodedBytes, offset, length)) {
       return new Utf16leBytesToCodeUnitsDecoder(utf16EncodedBytes, offset + 2,
           length - 2, false, replacementCodepoint);
     } else {
       return new Utf16beBytesToCodeUnitsDecoder(utf16EncodedBytes, offset,
           length, false, replacementCodepoint);
     }
   }
 
   /**
    * Provides a fast way to decode the rest of the source bytes in a single
    * call. This method trades memory for improved speed in that it potentially
    * over-allocates the List containing results.
    */
   List<int> decodeRest() {
-    List<int> codeunits = new List<int>(remaining);
+    List<int> codeunits = new List<int>.fixedLength(remaining);
     int i = 0;
-    while (hasNext) {
-      codeunits[i++] = next();
+    while (moveNext()) {
+      codeunits[i++] = current;
     }
     if (i == codeunits.length) {
       return codeunits;
     } else {
-      List<int> truncCodeunits = new List<int>(i);
+      List<int> truncCodeunits = new List<int>.fixedLength(i);
       truncCodeunits.setRange(0, i, codeunits);
       return truncCodeunits;
     }
   }
 
-  bool get hasNext => utf16EncodedBytesIterator.hasNext;
+  int get current => _current;
 
-  int next() {
+  bool moveNext() {
+    _current = null;
     if (utf16EncodedBytesIterator.remaining < 2) {
-      utf16EncodedBytesIterator.next();
+      utf16EncodedBytesIterator.moveNext();
       if (replacementCodepoint != null) {
-        return replacementCodepoint;
+        _current = replacementCodepoint;
+        return true;
       } else {
         throw new ArgumentError(
             "Invalid UTF16 at ${utf16EncodedBytesIterator.position}");
       }
     } else {
-      return decode();
+      _current = decode();
+      return true;
     }
   }
 
   int get position => utf16EncodedBytesIterator.position ~/ 2;
 
   void backup([int by = 1]) {
     utf16EncodedBytesIterator.backup(2 * by);
   }
 
   int get remaining => (utf16EncodedBytesIterator.remaining + 1) ~/ 2;
 
   void skip([int count = 1]) {
     utf16EncodedBytesIterator.skip(2 * count);
   }
 
   int decode();
 }
 
 /**
  * Convert UTF-16BE encoded bytes to utf16 code units by grouping 1-2 bytes
  * to produce the code unit (0-(2^16)-1).
  */
 class Utf16beBytesToCodeUnitsDecoder extends Utf16BytesToCodeUnitsDecoder {
   Utf16beBytesToCodeUnitsDecoder(List<int> utf16EncodedBytes, [
       int offset = 0, int length, bool stripBom = true,
       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) :
-      super._fromListRangeIterator((new _ListRange(utf16EncodedBytes, offset,
-      length)).iterator(), replacementCodepoint) {
+      super._fromListRangeIterator(
+          (new _ListRange(utf16EncodedBytes, offset, length)).iterator,
+          replacementCodepoint) {
     if (stripBom && hasUtf16beBom(utf16EncodedBytes, offset, length)) {
       skip();
     }
   }
 
   int decode() {
-    int hi = utf16EncodedBytesIterator.next();
-    int lo = utf16EncodedBytesIterator.next();
+    utf16EncodedBytesIterator.moveNext();
+    int hi = utf16EncodedBytesIterator.current;
+    utf16EncodedBytesIterator.moveNext();
+    int lo = utf16EncodedBytesIterator.current;
     return (hi << 8) + lo;
   }
 }
 
 /**
  * Convert UTF-16LE encoded bytes to utf16 code units by grouping 1-2 bytes
  * to produce the code unit (0-(2^16)-1).
  */
 class Utf16leBytesToCodeUnitsDecoder extends Utf16BytesToCodeUnitsDecoder {
   Utf16leBytesToCodeUnitsDecoder(List<int> utf16EncodedBytes, [
       int offset = 0, int length, bool stripBom = true,
       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) :
-      super._fromListRangeIterator((new _ListRange(utf16EncodedBytes, offset,
-      length)).iterator(), replacementCodepoint) {
+      super._fromListRangeIterator(
+          (new _ListRange(utf16EncodedBytes, offset, length)).iterator,
+          replacementCodepoint) {
     if (stripBom && hasUtf16leBom(utf16EncodedBytes, offset, length)) {
       skip();
     }
   }
 
   int decode() {
-    int lo = utf16EncodedBytesIterator.next();
-    int hi = utf16EncodedBytesIterator.next();
+    utf16EncodedBytesIterator.moveNext();
+    int lo = utf16EncodedBytesIterator.current;
+    utf16EncodedBytesIterator.moveNext();
+    int hi = utf16EncodedBytesIterator.current;
     return (hi << 8) + lo;
   }
 }