Add List.unmodifiable constructor.

sdk/lib/_internal/compiler/js_lib/js_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.
 
 part of _interceptors;
 
 /**
  * The interceptor class for [List]. The compiler recognizes this
  * class as an interceptor, and changes references to [:this:] to
  * actually use the receiver of the method, which is generated as an extra
@@ skipping 59 matching lines @@
       JS('JSExtendableArray', '#', new JSArray<E>.typed(allocation));
 
   static List markFixedList(List list) {
     // Functions are stored in the hidden class and not as properties in
     // the object. We never actually look at the value, but only want
     // to know if the property exists.
     JS('void', r'#.fixed$length = Array', list);
     return JS('JSFixedArray', '#', list);
   }
 
+  static List markUnmodifiableList(List list) {
+    // Functions are stored in the hidden class and not as properties in
+    // the object. We never actually look at the value, but only want
+    // to know if the property exists.
+    JS('void', r'#.fixed$length = Array', list);
+    JS('void', r'#.immutable$list = Array', list);
+    return JS('List', '#', list);

[sra1, 2015/04/22 21:17:31]

1. Change 'List' to 'JSArray'.

Leaving it as List means that the result of 'new List.unmodifiable(...)' will
never be optimized since it could be any implementation of List.

At least with JSArray we won't always be calling getInterceptor().

2. Open a bug against Dart2JS to recognize that unmodifiable lists have fixed
length.  Add a TODO here referencing the issue.

+  }
+
   checkMutable(reason) {
     if (this is !JSMutableArray) {
       throw new UnsupportedError(reason);
     }
   }
 
   checkGrowable(reason) {
     if (this is !JSExtendableArray) {
       throw new UnsupportedError(reason);
     }
   }
 
   void add(E value) {
     checkGrowable('add');
     JS('void', r'#.push(#)', this, value);
   }
 
   E removeAt(int index) {
+    checkGrowable('removeAt');
     if (index is !int) throw new ArgumentError(index);
     if (index < 0 || index >= length) {
       throw new RangeError.value(index);
     }
-    checkGrowable('removeAt');
     return JS('var', r'#.splice(#, 1)[0]', this, index);
   }
 
   void insert(int index, E value) {
+    checkGrowable('insert');
     if (index is !int) throw new ArgumentError(index);
     if (index < 0 || index > length) {
       throw new RangeError.value(index);
     }
-    checkGrowable('insert');
     JS('void', r'#.splice(#, 0, #)', this, index, value);
   }
 
   void insertAll(int index, Iterable<E> iterable) {
     checkGrowable('insertAll');
     RangeError.checkValueInInterval(index, 0, this.length, "index");
     if (iterable is! EfficientLength) {
       iterable = iterable.toList();
     }
     int insertionLength = iterable.length;
@@ skipping 70 matching lines @@
 
   Iterable<E> where(bool f(E element)) {
     return new WhereIterable<E>(this, f);
   }
 
   Iterable expand(Iterable f(E element)) {
     return new ExpandIterable<E, dynamic>(this, f);
   }
 
   void addAll(Iterable<E> collection) {
+    checkGrowable('addAll');
     for (E e in collection) {
-      this.add(e);
+      JS('void', r'#.push(#)', this, e);
     }
   }
 
   void clear() {
     length = 0;
   }
 
   void forEach(void f(E element)) {
     int end = this.length;
     for (int i = 0; i < end; i++) {
@@ skipping 343 matching lines @@
 
   Set<E> toSet() => new Set<E>.from(this);
 
   Iterator<E> get iterator => new ArrayIterator<E>(this);
 
   int get hashCode => Primitives.objectHashCode(this);
 
   int get length => JS('JSUInt32', r'#.length', this);
 
   void set length(int newLength) {
+    checkGrowable('set length');
     if (newLength is !int) throw new ArgumentError(newLength);
     if (newLength < 0) throw new RangeError.value(newLength);
-    checkGrowable('set length');
     JS('void', r'#.length = #', this, newLength);
   }
 
   E operator [](int index) {
     if (index is !int) throw new ArgumentError(index);
     if (index >= length || index < 0) throw new RangeError.value(index);
     return JS('var', '#[#]', this, index);
   }
 
   void operator []=(int index, E value) {
@@ skipping 49 matching lines @@
 
     if (_index >= length) {
       _current = null;
       return false;
     }
     _current = _iterable[_index];
     _index++;
     return true;
   }
 }