Implement List<T> operations on dom types via manual mixins.

client/dom/frog/dom_frog.dart

 #library('dom');
 
 // 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.
 
 // DO NOT EDIT
 // Auto-generated Dart DOM library.
 
 
@@ skipping 570 matching lines @@
   void addColorStop(num offset, String color) native;
 }
 
 class CanvasPatternJs extends DOMTypeJs implements CanvasPattern native "*CanvasPattern" {
 }
 
 class CanvasPixelArrayJs extends DOMTypeJs implements CanvasPixelArray native "*CanvasPixelArray" {
 
   int get length() native "return this.length;";
 
-  int operator[](int index) native;
+  int operator[](int index) native "return this[index];";
 
-  void operator[]=(int index, int value) native;
+  void operator[]=(int index, int value) native "this[index] = value";
+  // -- start List<int> mixins.
+  // int is the element type.
+
+  // From Iterable<int>:
+
+  Iterator<int> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<int>(this);
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<int> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(int element)) => _Collections.forEach(this, f);
+
+  Collection map(f(int element)) => _Collections.map(this, [], f);
+
+  Collection<int> filter(bool f(int element)) =>
+     _Collections.filter(this, <int>[], f);
+
+  bool every(bool f(int element)) => _Collections.every(this, f);
+
+  bool some(bool f(int element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<int>:
+
+  void sort(int compare(int a, int b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(int element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(int element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  int last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<int> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [int initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<int> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <int>[]);
+
+  // -- end List<int> mixins.
 }
 
 class CanvasRenderingContextJs extends DOMTypeJs implements CanvasRenderingContext native "*CanvasRenderingContext" {
 
   HTMLCanvasElementJs get canvas() native "return this.canvas;";
 }
 
 class CanvasRenderingContext2DJs extends CanvasRenderingContextJs implements CanvasRenderingContext2D native "*CanvasRenderingContext2D" {
 
   Dynamic get fillStyle() native "return this.fillStyle;";
@@ skipping 1785 matching lines @@
   factory Float32Array.fromList(List<num> list) => _construct(list);
 
   factory Float32Array.fromBuffer(ArrayBuffer buffer) => _construct(buffer);
 
   static _construct(arg) native 'return new Float32Array(arg);';
 
   static final int BYTES_PER_ELEMENT = 4;
 
   int get length() native "return this.length;";
 
-  num operator[](int index) native;
+  num operator[](int index) native "return this[index];";
 
-  void operator[]=(int index, num value) native;
+  void operator[]=(int index, num value) native "this[index] = value";
+  // -- start List<num> mixins.
+  // num is the element type.
+
+  // From Iterable<num>:
+
+  Iterator<num> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<num>(this);
+  }
+
+  // From Collection<num>:
+
+  void add(num value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(num value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<num> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(num element)) => _Collections.forEach(this, f);
+
+  Collection map(f(num element)) => _Collections.map(this, [], f);
+
+  Collection<num> filter(bool f(num element)) =>
+     _Collections.filter(this, <num>[], f);
+
+  bool every(bool f(num element)) => _Collections.every(this, f);
+
+  bool some(bool f(num element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<num>:
+
+  void sort(int compare(num a, num b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(num element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(num element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  num last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<num> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [num initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<num> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <num>[]);
+
+  // -- end List<num> mixins.
 
   void setElements(Object array, [int offset = null]) native;
 
   Float32ArrayJs subarray(int start, [int end = null]) native;
 }
 
 class Float64ArrayJs extends ArrayBufferViewJs implements Float64Array, List<num> native "*Float64Array" {
 
   factory Float64Array(int length) =>  _construct(length);
 
   factory Float64Array.fromList(List<num> list) => _construct(list);
 
   factory Float64Array.fromBuffer(ArrayBuffer buffer) => _construct(buffer);
 
   static _construct(arg) native 'return new Float64Array(arg);';
 
   static final int BYTES_PER_ELEMENT = 8;
 
   int get length() native "return this.length;";
 
-  num operator[](int index) native;
+  num operator[](int index) native "return this[index];";
 
-  void operator[]=(int index, num value) native;
+  void operator[]=(int index, num value) native "this[index] = value";
+  // -- start List<num> mixins.
+  // num is the element type.
+
+  // From Iterable<num>:
+
+  Iterator<num> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<num>(this);
+  }
+
+  // From Collection<num>:
+
+  void add(num value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(num value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<num> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(num element)) => _Collections.forEach(this, f);
+
+  Collection map(f(num element)) => _Collections.map(this, [], f);
+
+  Collection<num> filter(bool f(num element)) =>
+     _Collections.filter(this, <num>[], f);
+
+  bool every(bool f(num element)) => _Collections.every(this, f);
+
+  bool some(bool f(num element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<num>:
+
+  void sort(int compare(num a, num b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(num element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(num element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  num last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<num> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [num initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<num> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <num>[]);
+
+  // -- end List<num> mixins.
 
   void setElements(Object array, [int offset = null]) native;
 
   Float64ArrayJs subarray(int start, [int end = null]) native;
 }
 
 class GeolocationJs extends DOMTypeJs implements Geolocation native "*Geolocation" {
 
   void clearWatch(int watchId) native;
 
@@ skipping 329 matching lines @@
 
   Object getContext(String contextId) native;
 
   String toDataURL(String type) native;
 }
 
 class HTMLCollectionJs extends DOMTypeJs implements HTMLCollection native "*HTMLCollection" {
 
   int get length() native "return this.length;";
 
-  NodeJs operator[](int index) native;
+  NodeJs operator[](int index) native "return this[index];";
 
   void operator[]=(int index, NodeJs value) {
     throw new UnsupportedOperationException("Cannot assign element of immutable List.");
   }
+  // -- start List<Node> mixins.
+  // Node is the element type.
+
+  // From Iterable<Node>:
+
+  Iterator<Node> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<Node>(this);
+  }
+
+  // From Collection<Node>:
+
+  void add(Node value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(Node value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<Node> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(Node element)) => _Collections.forEach(this, f);
+
+  Collection map(f(Node element)) => _Collections.map(this, [], f);
+
+  Collection<Node> filter(bool f(Node element)) =>
+     _Collections.filter(this, <Node>[], f);
+
+  bool every(bool f(Node element)) => _Collections.every(this, f);
+
+  bool some(bool f(Node element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<Node>:
+
+  void sort(int compare(Node a, Node b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(Node element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(Node element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  Node last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<Node> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [Node initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<Node> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <Node>[]);
+
+  // -- end List<Node> mixins.
 
   NodeJs item(int index) native;
 
   NodeJs namedItem(String name) native;
 }
 
 class HTMLDListElementJs extends HTMLElementJs implements HTMLDListElement native "*HTMLDListElement" {
 
   bool get compact() native "return this.compact;";
 
@@ skipping 2319 matching lines @@
   factory Int16Array.fromList(List<int> list) => _construct(list);
 
   factory Int16Array.fromBuffer(ArrayBuffer buffer) => _construct(buffer);
 
   static _construct(arg) native 'return new Int16Array(arg);';
 
   static final int BYTES_PER_ELEMENT = 2;
 
   int get length() native "return this.length;";
 
-  int operator[](int index) native;
+  int operator[](int index) native "return this[index];";
 
-  void operator[]=(int index, int value) native;
+  void operator[]=(int index, int value) native "this[index] = value";
+  // -- start List<int> mixins.
+  // int is the element type.
+
+  // From Iterable<int>:
+
+  Iterator<int> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<int>(this);
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<int> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(int element)) => _Collections.forEach(this, f);
+
+  Collection map(f(int element)) => _Collections.map(this, [], f);
+
+  Collection<int> filter(bool f(int element)) =>
+     _Collections.filter(this, <int>[], f);
+
+  bool every(bool f(int element)) => _Collections.every(this, f);
+
+  bool some(bool f(int element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<int>:
+
+  void sort(int compare(int a, int b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(int element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(int element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  int last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<int> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [int initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<int> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <int>[]);
+
+  // -- end List<int> mixins.
 
   void setElements(Object array, [int offset = null]) native;
 
   Int16ArrayJs subarray(int start, [int end = null]) native;
 }
 
 class Int32ArrayJs extends ArrayBufferViewJs implements Int32Array, List<int> native "*Int32Array" {
 
   factory Int32Array(int length) =>  _construct(length);
 
   factory Int32Array.fromList(List<int> list) => _construct(list);
 
   factory Int32Array.fromBuffer(ArrayBuffer buffer) => _construct(buffer);
 
   static _construct(arg) native 'return new Int32Array(arg);';
 
   static final int BYTES_PER_ELEMENT = 4;
 
   int get length() native "return this.length;";
 
-  int operator[](int index) native;
+  int operator[](int index) native "return this[index];";
 
-  void operator[]=(int index, int value) native;
+  void operator[]=(int index, int value) native "this[index] = value";
+  // -- start List<int> mixins.
+  // int is the element type.
+
+  // From Iterable<int>:
+
+  Iterator<int> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<int>(this);
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<int> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(int element)) => _Collections.forEach(this, f);
+
+  Collection map(f(int element)) => _Collections.map(this, [], f);
+
+  Collection<int> filter(bool f(int element)) =>
+     _Collections.filter(this, <int>[], f);
+
+  bool every(bool f(int element)) => _Collections.every(this, f);
+
+  bool some(bool f(int element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<int>:
+
+  void sort(int compare(int a, int b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(int element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(int element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  int last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<int> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [int initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<int> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <int>[]);
+
+  // -- end List<int> mixins.
 
   void setElements(Object array, [int offset = null]) native;
 
   Int32ArrayJs subarray(int start, [int end = null]) native;
 }
 
 class Int8ArrayJs extends ArrayBufferViewJs implements Int8Array, List<int> native "*Int8Array" {
 
   factory Int8Array(int length) =>  _construct(length);
 
   factory Int8Array.fromList(List<int> list) => _construct(list);
 
   factory Int8Array.fromBuffer(ArrayBuffer buffer) => _construct(buffer);
 
   static _construct(arg) native 'return new Int8Array(arg);';
 
   static final int BYTES_PER_ELEMENT = 1;
 
   int get length() native "return this.length;";
 
-  int operator[](int index) native;
+  int operator[](int index) native "return this[index];";
 
-  void operator[]=(int index, int value) native;
+  void operator[]=(int index, int value) native "this[index] = value";
+  // -- start List<int> mixins.
+  // int is the element type.
+
+  // From Iterable<int>:
+
+  Iterator<int> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<int>(this);
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<int> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(int element)) => _Collections.forEach(this, f);
+
+  Collection map(f(int element)) => _Collections.map(this, [], f);
+
+  Collection<int> filter(bool f(int element)) =>
+     _Collections.filter(this, <int>[], f);
+
+  bool every(bool f(int element)) => _Collections.every(this, f);
+
+  bool some(bool f(int element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<int>:
+
+  void sort(int compare(int a, int b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(int element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(int element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  int last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<int> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [int initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<int> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <int>[]);
+
+  // -- end List<int> mixins.
 
   void setElements(Object array, [int offset = null]) native;
 
   Int8ArrayJs subarray(int start, [int end = null]) native;
 }
 
 class JavaScriptAudioNodeJs extends AudioNodeJs implements JavaScriptAudioNode native "*JavaScriptAudioNode" {
 
   int get bufferSize() native "return this.bufferSize;";
 
@@ skipping 166 matching lines @@
 }
 
 class MediaListJs extends DOMTypeJs implements MediaList native "*MediaList" {
 
   int get length() native "return this.length;";
 
   String get mediaText() native "return this.mediaText;";
 
   void set mediaText(String value) native "this.mediaText = value;";
 
-  String operator[](int index) native;
+  String operator[](int index) native "return this[index];";
 
   void operator[]=(int index, String value) {
     throw new UnsupportedOperationException("Cannot assign element of immutable List.");
   }
+  // -- start List<String> mixins.
+  // String is the element type.
+
+  // From Iterable<String>:
+
+  Iterator<String> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<String>(this);
+  }
+
+  // From Collection<String>:
+
+  void add(String value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(String value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<String> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(String element)) => _Collections.forEach(this, f);
+
+  Collection map(f(String element)) => _Collections.map(this, [], f);
+
+  Collection<String> filter(bool f(String element)) =>
+     _Collections.filter(this, <String>[], f);
+
+  bool every(bool f(String element)) => _Collections.every(this, f);
+
+  bool some(bool f(String element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<String>:
+
+  void sort(int compare(String a, String b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(String element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(String element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  String last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<String> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [String initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<String> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <String>[]);
+
+  // -- end List<String> mixins.
 
   void appendMedium(String newMedium) native;
 
   void deleteMedium(String oldMedium) native;
 
   String item(int index) native;
 }
 
 class MediaQueryListJs extends DOMTypeJs implements MediaQueryList native "*MediaQueryList" {
 
@@ skipping 151 matching lines @@
 
   NodeJs get target() native "return this.target;";
 
   String get type() native "return this.type;";
 }
 
 class NamedNodeMapJs extends DOMTypeJs implements NamedNodeMap native "*NamedNodeMap" {
 
   int get length() native "return this.length;";
 
-  NodeJs operator[](int index) native;
+  NodeJs operator[](int index) native "return this[index];";
 
   void operator[]=(int index, NodeJs value) {
     throw new UnsupportedOperationException("Cannot assign element of immutable List.");
   }
+  // -- start List<Node> mixins.
+  // Node is the element type.
+
+  // From Iterable<Node>:
+
+  Iterator<Node> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<Node>(this);
+  }
+
+  // From Collection<Node>:
+
+  void add(Node value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(Node value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<Node> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(Node element)) => _Collections.forEach(this, f);
+
+  Collection map(f(Node element)) => _Collections.map(this, [], f);
+
+  Collection<Node> filter(bool f(Node element)) =>
+     _Collections.filter(this, <Node>[], f);
+
+  bool every(bool f(Node element)) => _Collections.every(this, f);
+
+  bool some(bool f(Node element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<Node>:
+
+  void sort(int compare(Node a, Node b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(Node element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(Node element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  Node last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<Node> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [Node initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<Node> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <Node>[]);
+
+  // -- end List<Node> mixins.
 
   NodeJs getNamedItem(String name) native;
 
   NodeJs getNamedItemNS(String namespaceURI, String localName) native;
 
   NodeJs item(int index) native;
 
   NodeJs removeNamedItem(String name) native;
 
   NodeJs removeNamedItemNS(String namespaceURI, String localName) native;
@@ skipping 214 matching lines @@
 
   NodeJs nextNode() native;
 
   NodeJs previousNode() native;
 }
 
 class NodeListJs extends DOMTypeJs implements NodeList native "*NodeList" {
 
   int get length() native "return this.length;";
 
-  NodeJs operator[](int index) native;
+  NodeJs operator[](int index) native "return this[index];";
 
   void operator[]=(int index, NodeJs value) {
     throw new UnsupportedOperationException("Cannot assign element of immutable List.");
   }
+  // -- start List<Node> mixins.
+  // Node is the element type.
+
+  // From Iterable<Node>:
+
+  Iterator<Node> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<Node>(this);
+  }
+
+  // From Collection<Node>:
+
+  void add(Node value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(Node value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<Node> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(Node element)) => _Collections.forEach(this, f);
+
+  Collection map(f(Node element)) => _Collections.map(this, [], f);
+
+  Collection<Node> filter(bool f(Node element)) =>
+     _Collections.filter(this, <Node>[], f);
+
+  bool every(bool f(Node element)) => _Collections.every(this, f);
+
+  bool some(bool f(Node element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<Node>:
+
+  void sort(int compare(Node a, Node b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(Node element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(Node element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  Node last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<Node> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [Node initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<Node> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <Node>[]);
+
+  // -- end List<Node> mixins.
 
   NodeJs item(int index) native;
 }
 
 class NodeSelectorJs extends DOMTypeJs implements NodeSelector native "*NodeSelector" {
 
   ElementJs querySelector(String selectors) native;
 
   NodeListJs querySelectorAll(String selectors) native;
 }
@@ skipping 4157 matching lines @@
 
   String get title() native "return this.title;";
 
   String get type() native "return this.type;";
 }
 
 class StyleSheetListJs extends DOMTypeJs implements StyleSheetList native "*StyleSheetList" {
 
   int get length() native "return this.length;";
 
-  StyleSheetJs operator[](int index) native;
+  StyleSheetJs operator[](int index) native "return this[index];";
 
   void operator[]=(int index, StyleSheetJs value) {
     throw new UnsupportedOperationException("Cannot assign element of immutable List.");
   }
+  // -- start List<StyleSheet> mixins.
+  // StyleSheet is the element type.
+
+  // From Iterable<StyleSheet>:
+
+  Iterator<StyleSheet> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<StyleSheet>(this);
+  }
+
+  // From Collection<StyleSheet>:
+
+  void add(StyleSheet value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(StyleSheet value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<StyleSheet> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(StyleSheet element)) => _Collections.forEach(this, f);
+
+  Collection map(f(StyleSheet element)) => _Collections.map(this, [], f);
+
+  Collection<StyleSheet> filter(bool f(StyleSheet element)) =>
+     _Collections.filter(this, <StyleSheet>[], f);
+
+  bool every(bool f(StyleSheet element)) => _Collections.every(this, f);
+
+  bool some(bool f(StyleSheet element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<StyleSheet>:
+
+  void sort(int compare(StyleSheet a, StyleSheet b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(StyleSheet element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(StyleSheet element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  StyleSheet last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<StyleSheet> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [StyleSheet initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<StyleSheet> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <StyleSheet>[]);
+
+  // -- end List<StyleSheet> mixins.
 
   StyleSheetJs item(int index) native;
 }
 
 class TextJs extends CharacterDataJs implements Text native "*Text" {
 
   String get wholeText() native "return this.wholeText;";
 
   TextJs replaceWholeText(String content) native;
 
@@ skipping 192 matching lines @@
 
   TouchListJs get touches() native "return this.touches;";
 
   void initTouchEvent(TouchListJs touches, TouchListJs targetTouches, TouchListJs changedTouches, String type, DOMWindowJs view, int screenX, int screenY, int clientX, int clientY, bool ctrlKey, bool altKey, bool shiftKey, bool metaKey) native;
 }
 
 class TouchListJs extends DOMTypeJs implements TouchList native "*TouchList" {
 
   int get length() native "return this.length;";
 
-  TouchJs operator[](int index) native;
+  TouchJs operator[](int index) native "return this[index];";
 
   void operator[]=(int index, TouchJs value) {
     throw new UnsupportedOperationException("Cannot assign element of immutable List.");
   }
+  // -- start List<Touch> mixins.
+  // Touch is the element type.
+
+  // From Iterable<Touch>:
+
+  Iterator<Touch> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<Touch>(this);
+  }
+
+  // From Collection<Touch>:
+
+  void add(Touch value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(Touch value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<Touch> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(Touch element)) => _Collections.forEach(this, f);
+
+  Collection map(f(Touch element)) => _Collections.map(this, [], f);
+
+  Collection<Touch> filter(bool f(Touch element)) =>
+     _Collections.filter(this, <Touch>[], f);
+
+  bool every(bool f(Touch element)) => _Collections.every(this, f);
+
+  bool some(bool f(Touch element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<Touch>:
+
+  void sort(int compare(Touch a, Touch b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(Touch element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(Touch element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  Touch last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<Touch> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [Touch initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<Touch> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <Touch>[]);
+
+  // -- end List<Touch> mixins.
 
   TouchJs item(int index) native;
 }
 
 class TrackEventJs extends EventJs implements TrackEvent native "*TrackEvent" {
 
   Object get track() native "return this.track;";
 }
 
 class TreeWalkerJs extends DOMTypeJs implements TreeWalker native "*TreeWalker" {
@@ skipping 55 matching lines @@
   factory Uint16Array.fromList(List<int> list) => _construct(list);
 
   factory Uint16Array.fromBuffer(ArrayBuffer buffer) => _construct(buffer);
 
   static _construct(arg) native 'return new Uint16Array(arg);';
 
   static final int BYTES_PER_ELEMENT = 2;
 
   int get length() native "return this.length;";
 
-  int operator[](int index) native;
+  int operator[](int index) native "return this[index];";
 
-  void operator[]=(int index, int value) native;
+  void operator[]=(int index, int value) native "this[index] = value";
+  // -- start List<int> mixins.
+  // int is the element type.
+
+  // From Iterable<int>:
+
+  Iterator<int> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<int>(this);
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<int> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(int element)) => _Collections.forEach(this, f);
+
+  Collection map(f(int element)) => _Collections.map(this, [], f);
+
+  Collection<int> filter(bool f(int element)) =>
+     _Collections.filter(this, <int>[], f);
+
+  bool every(bool f(int element)) => _Collections.every(this, f);
+
+  bool some(bool f(int element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<int>:
+
+  void sort(int compare(int a, int b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(int element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(int element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  int last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<int> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [int initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<int> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <int>[]);
+
+  // -- end List<int> mixins.
 
   void setElements(Object array, [int offset = null]) native;
 
   Uint16ArrayJs subarray(int start, [int end = null]) native;
 }
 
 class Uint32ArrayJs extends ArrayBufferViewJs implements Uint32Array, List<int> native "*Uint32Array" {
 
   factory Uint32Array(int length) =>  _construct(length);
 
   factory Uint32Array.fromList(List<int> list) => _construct(list);
 
   factory Uint32Array.fromBuffer(ArrayBuffer buffer) => _construct(buffer);
 
   static _construct(arg) native 'return new Uint32Array(arg);';
 
   static final int BYTES_PER_ELEMENT = 4;
 
   int get length() native "return this.length;";
 
-  int operator[](int index) native;
+  int operator[](int index) native "return this[index];";
 
-  void operator[]=(int index, int value) native;
+  void operator[]=(int index, int value) native "this[index] = value";
+  // -- start List<int> mixins.
+  // int is the element type.
+
+  // From Iterable<int>:
+
+  Iterator<int> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<int>(this);
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<int> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(int element)) => _Collections.forEach(this, f);
+
+  Collection map(f(int element)) => _Collections.map(this, [], f);
+
+  Collection<int> filter(bool f(int element)) =>
+     _Collections.filter(this, <int>[], f);
+
+  bool every(bool f(int element)) => _Collections.every(this, f);
+
+  bool some(bool f(int element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<int>:
+
+  void sort(int compare(int a, int b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(int element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(int element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  int last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<int> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [int initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<int> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <int>[]);
+
+  // -- end List<int> mixins.
 
   void setElements(Object array, [int offset = null]) native;
 
   Uint32ArrayJs subarray(int start, [int end = null]) native;
 }
 
 class Uint8ArrayJs extends ArrayBufferViewJs implements Uint8Array, List<int> native "*Uint8Array" {
 
   factory Uint8Array(int length) =>  _construct(length);
 
   factory Uint8Array.fromList(List<int> list) => _construct(list);
 
   factory Uint8Array.fromBuffer(ArrayBuffer buffer) => _construct(buffer);
 
   static _construct(arg) native 'return new Uint8Array(arg);';
 
   static final int BYTES_PER_ELEMENT = 1;
 
   int get length() native "return this.length;";
 
-  int operator[](int index) native;
+  int operator[](int index) native "return this[index];";
 
-  void operator[]=(int index, int value) native;
+  void operator[]=(int index, int value) native "this[index] = value";
+  // -- start List<int> mixins.
+  // int is the element type.
+
+  // From Iterable<int>:
+
+  Iterator<int> iterator() {
+    // Note: NodeLists are not fixed size. And most probably length shouldn't
+    // be cached in both iterator _and_ forEach method. For now caching it
+    // for consistency.
+    return new _FixedSizeListIterator<int>(this);
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void addAll(Collection<int> collection) {
+    throw new UnsupportedOperationException("Cannot add to immutable List.");
+  }
+
+  void forEach(void f(int element)) => _Collections.forEach(this, f);
+
+  Collection map(f(int element)) => _Collections.map(this, [], f);
+
+  Collection<int> filter(bool f(int element)) =>
+     _Collections.filter(this, <int>[], f);
+
+  bool every(bool f(int element)) => _Collections.every(this, f);
+
+  bool some(bool f(int element)) => _Collections.some(this, f);
+
+  bool isEmpty() => this.length == 0;
+
+  // From List<int>:
+
+  void sort(int compare(int a, int b)) {
+    throw new UnsupportedOperationException("Cannot sort immutable List.");
+  }
+
+  int indexOf(int element, [int start = 0]) =>
+      _Lists.indexOf(this, element, start, this.length);
+
+  int lastIndexOf(int element, [int start = 0]) =>
+      _Lists.lastIndexOf(this, element, start);
+
+  int last() => this[length - 1];
+
+  // FIXME: implement thesee.
+  void setRange(int start, int length, List<int> from, [int startFrom]) {
+    throw new UnsupportedOperationException("Cannot setRange on immutable List.");
+  }
+  void removeRange(int start, int length) {
+    throw new UnsupportedOperationException("Cannot removeRange on immutable List.");
+  }
+  void insertRange(int start, int length, [int initialValue]) {
+    throw new UnsupportedOperationException("Cannot insertRange on immutable List.");
+  }
+  List<int> getRange(int start, int length) =>
+      _Lists.getRange(this, start, length, <int>[]);
+
+  // -- end List<int> mixins.
 
   void setElements(Object array, [int offset = null]) native;
 
   Uint8ArrayJs subarray(int start, [int end = null]) native;
 }
 
 class ValidityStateJs extends DOMTypeJs implements ValidityState native "*ValidityState" {
 
   bool get customError() native "return this.customError;";
 
@@ skipping 15405 matching lines @@
     if (startIndex >= a.length) {
       startIndex = a.length - 1;
     }
     for (int i = startIndex; i >= 0; i--) {
       if (a[i] == element) {
         return i;
       }
     }
     return -1;
   }
+
+  /**
+   * Returns a sub list copy of this list, from [start] to
+   * [:start + length:].
+   * Returns an empty list if [length] is 0.
+   * Throws an [IllegalArgumentException] if [length] is negative.
+   * Throws an [IndexOutOfRangeException] if [start] or
+   * [:start + length:] are out of range.
+   */
+  static List getRange(List a, int start, int length, List accumulator) {
+    if (length < 0) throw new IllegalArgumentException('length');
+    if (start < 0) throw new IndexOutOfRangeException(start);
+    int end = start + length;
+    if (end > a.length) throw new IndexOutOfRangeException(end);
+    for (int i = start; i < end; i++) {
+      accumulator.add(a[i]);
+    }
+    return accumulator;
+  }
 }