Let Uint16List.setRange detect a String.codeUnits object, and copy directly from the string.

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 811 matching lines @@
   void _setFloat32x4(int offsetInBytes, Float32x4 value)
       native "TypedData_SetFloat32x4";
 
   Int32x4 _getInt32x4(int offsetInBytes) native "TypedData_GetInt32x4";
   void _setInt32x4(int offsetInBytes, Int32x4 value)
       native "TypedData_SetInt32x4";
 
   Float64x2 _getFloat64x2(int offsetInBytes) native "TypedData_GetFloat64x2";
   void _setFloat64x2(int offsetInBytes, Float64x2 value)
       native "TypedData_SetFloat64x2";
+
+  /** Writes the code units of `string.substring(start, end)` as Uint16. */
+  void _setStringAt(int byteOffset, String string, int start, int end) {
+    // This can be optimized to a mem-move if string is two-byte.
+    int length = end - start;
+    assert(byteOffset + length * Uint16List.BYTES_PER_ELEMENT <=
+           this.lengthInBytes);
+    for (int i = 0; i < length; i++) {
+      _setUint16(byteOffset + i * Uint16List.BYTES_PER_ELEMENT,
+                 string.codeUnitAt(start + i));
+    }
+  }
+
+  void _setCodeUnits(CodeUnits units, int start, int end, int skipCount) {
+    String string = CodeUnits.stringOf(units);
+    end = RangeError.checkValidRange(start, end, length);
+    int sliceLength = end - start;
+    int sliceEnd = skipCount + sliceLength;
+    RangeError.checkValidRange(skipCount, sliceEnd,
+                               string.length,
+                               "skipCount", "skipCount + length");
+    this._setStringAt(start * elementSizeInBytes, string, skipCount, sliceEnd);
+  }
 }
 
 
 class _Int8Array extends _TypedList with _IntListMixin implements Int8List {
   // Factory constructors.
 
   factory _Int8Array(int length) {
     return _new(length);
   }
 
@@ skipping 180 matching lines @@
     return _getIndexedUint16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw _newRangeError(index, length);
     }
     _setIndexedUint16(index, _toUint16(value));
   }
 
+  void setRange(int start, int end, Iterable iterable, [int skipCount = 0]) {
+    if (ClassID.getID(iterable) != CodeUnits.cid) {
+      super.setRange(start, end, iterable, skipCount);
+    } else {
+      _setCodeUnits(iterable, start, end, skipCount);

[Vyacheslav Egorov (Google), 2015/01/29 13:04:54]

Maybe we should also have an optimization for Int8Array/Uint8Array and one byte
string in this CL?

It's also unclear to me why Int16Array is not covered by this optimization?

[Lasse Reichstein Nielsen, 2015/01/29 13:13:27]

I was planning to do that in a later CL.
Good point. Writing to an Int16Array and an Uint16Array is completely equivalent
(it's the same bits getting written in either case, it's only reading them back
that differs).

I'll add the setRange to Int16Array/View too.

+    }
+  }
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
@@ skipping 1404 matching lines @@
   // Method(s) implementing the TypedData interface.
 
   int get lengthInBytes {
     return length * elementSizeInBytes;
   }
 
   ByteBuffer get buffer {
     return _typedData.buffer;
   }
 
-  final TypedData _typedData;
+  final _TypedList _typedData;
   final int offsetInBytes;
   final int length;
 }
 
 
 class _Int8ArrayView extends _TypedListView with _IntListMixin implements Int8List {
   // Constructor.
   _Int8ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
@@ skipping 207 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       throw _newRangeError(index, length);
     }
     _typedData._setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
                           _toUint16(value));
   }
 
+  void setRange(int start, int end, Iterable iterable, [int skipCount = 0]) {
+    if (ClassID.getID(iterable) != CodeUnits.cid) {
+      super.setRange(start, end, iterable, skipCount);
+    } else {
+      _typed_Data._setCodeUnits(iterable, start, end, skipCount);
+    }
+  }
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
 
-
   // Internal utility methods.
 
   Uint16List _createList(int length) {
     return new Uint16List(length);
   }
 }
 
 
 class _Int32ArrayView extends _TypedListView with _IntListMixin implements Int32List {
   // Constructor.
@@ skipping 784 matching lines @@
     return value;
   }
   return object;
 }
 
 
 _newRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
   return new RangeError(message);
 }