Add List.insert.

sdk/lib/html/dartium/html_dartium.dart

Index: sdk/lib/html/dartium/html_dartium.dart
diff --git a/sdk/lib/html/dartium/html_dartium.dart b/sdk/lib/html/dartium/html_dartium.dart
index e1219575b74eb244c8a0528ac508bc9c663c7e6c..cbd8d2f292d178a60a6fcc682f989ceb06bb29c9 100644
--- a/sdk/lib/html/dartium/html_dartium.dart
+++ b/sdk/lib/html/dartium/html_dartium.dart
@@ -7998,6 +7998,10 @@ class DomMimeTypeArray extends NativeFieldWrapperClass1 implements List<DomMimeT
   DomMimeType max([int compare(DomMimeType a, DomMimeType b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, DomMimeType element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   DomMimeType removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -8271,6 +8275,10 @@ class DomPluginArray extends NativeFieldWrapperClass1 implements List<DomPlugin>
   DomPlugin max([int compare(DomPlugin a, DomPlugin b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, DomPlugin element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   DomPlugin removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -8662,6 +8670,10 @@ class DomStringList extends NativeFieldWrapperClass1 implements List<String> {
   String max([int compare(String a, String b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, String element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   String removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -8991,6 +9003,17 @@ class _ChildrenElementList implements List {
     return Lists.lastIndexOf(this, element, start);
   }
 
+  void insert(int index, Element element) {
+    if (index < 0 || index > length) {
+      throw new RangeError.range(index, 0, length);
+    }
+    if (index == length) {
+      _element.$dom_appendChild(element);
+    } else {
+      throw new UnimplementedError("insert on ElementLists");
+    }
+  }
+
   void clear() {
     // It is unclear if we want to keep non element nodes?
     _element.text = '';
@@ -11683,6 +11706,10 @@ class FileList extends NativeFieldWrapperClass1 implements List<File> {
   File max([int compare(File a, File b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, File element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   File removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -12299,6 +12326,10 @@ class Float32Array extends ArrayBufferView implements List<num> {
   num max([int compare(num a, num b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, num element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   num removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -12539,6 +12570,10 @@ class Float64Array extends ArrayBufferView implements List<num> {
   num max([int compare(num a, num b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, num element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   num removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -13228,6 +13263,10 @@ class HtmlAllCollection extends NativeFieldWrapperClass1 implements List<Node> {
   Node max([int compare(Node a, Node b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, Node element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -13442,6 +13481,10 @@ class HtmlCollection extends NativeFieldWrapperClass1 implements List<Node> {
   Node max([int compare(Node a, Node b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, Node element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -15767,6 +15810,10 @@ class Int16Array extends ArrayBufferView implements List<int> {
   int max([int compare(int a, int b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, int element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -16007,6 +16054,10 @@ class Int32Array extends ArrayBufferView implements List<int> {
   int max([int compare(int a, int b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, int element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -16247,6 +16298,10 @@ class Int8Array extends ArrayBufferView implements List<int> {
   int max([int compare(int a, int b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, int element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -18912,6 +18967,17 @@ class _ChildNodeListLazy implements List {
     }
   }
 
+  void insert(int index, Node node) {
+    if (index < 0 || index > length) {
+      throw new RangeError.range(index, 0, length);
+    }
+    if (index == length) {
+      _this.$dom_appendChild(node);
+    } else {
+      this_.insertBefore(node, this[index]);
+    }
+  }
+
   Node removeLast() {
     final result = last;
     if (result != null) {
@@ -19498,6 +19564,10 @@ class NodeList extends NativeFieldWrapperClass1 implements List<Node> {
   Node max([int compare(Node a, Node b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, Node element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -22197,6 +22267,10 @@ class SourceBufferList extends EventTarget implements List<SourceBuffer> {
   SourceBuffer max([int compare(SourceBuffer a, SourceBuffer b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, SourceBuffer element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   SourceBuffer removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -22520,6 +22594,10 @@ class SpeechGrammarList extends NativeFieldWrapperClass1 implements List<SpeechG
   SpeechGrammar max([int compare(SpeechGrammar a, SpeechGrammar b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, SpeechGrammar element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   SpeechGrammar removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -24208,6 +24286,10 @@ class TextTrackCueList extends NativeFieldWrapperClass1 implements List<TextTrac
   TextTrackCue max([int compare(TextTrackCue a, TextTrackCue b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, TextTrackCue element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   TextTrackCue removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -24422,6 +24504,10 @@ class TextTrackList extends EventTarget implements List<TextTrack> {
   TextTrack max([int compare(TextTrack a, TextTrack b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, TextTrack element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   TextTrack removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -24853,6 +24939,10 @@ class TouchList extends NativeFieldWrapperClass1 implements List<Touch> {
   Touch max([int compare(Touch a, Touch b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, Touch element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   Touch removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -25367,6 +25457,10 @@ class Uint16Array extends ArrayBufferView implements List<int> {
   int max([int compare(int a, int b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, int element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -25607,6 +25701,10 @@ class Uint32Array extends ArrayBufferView implements List<int> {
   int max([int compare(int a, int b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, int element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -25847,6 +25945,10 @@ class Uint8Array extends ArrayBufferView implements List<int> {
   int max([int compare(int a, int b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, int element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -26085,6 +26187,10 @@ class Uint8ClampedArray extends Uint8Array implements List<int> {
   int max([int compare(int a, int b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, int element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -29929,6 +30035,10 @@ class _ClientRectList extends NativeFieldWrapperClass1 implements List<Rect> {
   Rect max([int compare(Rect a, Rect b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, Rect element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   Rect removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -30135,6 +30245,10 @@ class _CssRuleList extends NativeFieldWrapperClass1 implements List<CssRule> {
   CssRule max([int compare(CssRule a, CssRule b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, CssRule element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   CssRule removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -30341,6 +30455,10 @@ class _CssValueList extends CssValue implements List<CssValue> {
   CssValue max([int compare(CssValue a, CssValue b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, CssValue element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   CssValue removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -30690,6 +30808,10 @@ class _EntryArray extends NativeFieldWrapperClass1 implements List<Entry> {
   Entry max([int compare(Entry a, Entry b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, Entry element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   Entry removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -30896,6 +31018,10 @@ class _EntryArraySync extends NativeFieldWrapperClass1 implements List<EntrySync
   EntrySync max([int compare(EntrySync a, EntrySync b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, EntrySync element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   EntrySync removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -31102,6 +31228,10 @@ class _GamepadList extends NativeFieldWrapperClass1 implements List<Gamepad> {
   Gamepad max([int compare(Gamepad a, Gamepad b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, Gamepad element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   Gamepad removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -31399,6 +31529,10 @@ class _NamedNodeMap extends NativeFieldWrapperClass1 implements List<Node> {
   Node max([int compare(Node a, Node b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, Node element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -31629,6 +31763,10 @@ class _SpeechInputResultList extends NativeFieldWrapperClass1 implements List<Sp
   SpeechInputResult max([int compare(SpeechInputResult a, SpeechInputResult b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, SpeechInputResult element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   SpeechInputResult removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -31835,6 +31973,10 @@ class _SpeechRecognitionResultList extends NativeFieldWrapperClass1 implements L
   SpeechRecognitionResult max([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, SpeechRecognitionResult element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   SpeechRecognitionResult removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -32041,6 +32183,10 @@ class _StyleSheetList extends NativeFieldWrapperClass1 implements List<StyleShee
   StyleSheet max([int compare(StyleSheet a, StyleSheet b)]) =>
       IterableMixinWorkaround.max(this, compare);
 
+  void insert(int index, StyleSheet element) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   StyleSheet removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
@@ -34347,6 +34493,8 @@ class _WrappedList<E> implements List<E> {
 
   int lastIndexOf(E element, [int start]) => _list.lastIndexOf(element, start);
 
+  void insert(int index, E element) => _list.insert(index, element);
+
   E removeAt(int index) => _list.removeAt(index);
 
   E removeLast() => _list.removeLast();