Change List.sort to not have a default parameter value.

sdk/lib/html/dartium/html_dartium.dart

 library html;
 
 import 'dart:collection';
 import 'dart:html_common';
 import 'dart:indexed_db';
 import 'dart:isolate';
 import 'dart:json';
 import 'dart:nativewrappers';
 import 'dart:svg' as svg;
 import 'dart:web_audio' as web_audio;
@@ skipping 6650 matching lines @@
      Collections.filter(this, <DOMMimeType>[], f);
 
   bool every(bool f(DOMMimeType element)) => Collections.every(this, f);
 
   bool some(bool f(DOMMimeType element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<DOMMimeType>:
 
-  void sort([Comparator<DOMMimeType> compare = Comparable.compare]) {
+  void sort([int compare(DOMMimeType a, DOMMimeType b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(DOMMimeType element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(DOMMimeType element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 150 matching lines @@
      Collections.filter(this, <DOMPlugin>[], f);
 
   bool every(bool f(DOMPlugin element)) => Collections.every(this, f);
 
   bool some(bool f(DOMPlugin element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<DOMPlugin>:
 
-  void sort([Comparator<DOMPlugin> compare = Comparable.compare]) {
+  void sort([int compare(DOMPlugin a, DOMPlugin b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(DOMPlugin element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(DOMPlugin element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 1576 matching lines @@
   Element addLast(Element value) => add(value);
 
   Iterator<Element> iterator() => _toList().iterator();
 
   void addAll(Collection<Element> collection) {
     for (Element element in collection) {
       _element.$dom_appendChild(element);
     }
   }
 
-  void sort([Comparator<Element> compare = Comparable.compare]) {
+  void sort([int compare(Element a, Element b)]) {
     throw new UnsupportedError('TODO(jacobr): should we impl?');
   }
 
   void setRange(int start, int rangeLength, List from, [int startFrom = 0]) {
     throw new UnimplementedError();
   }
 
   void removeRange(int start, int rangeLength) {
     throw new UnimplementedError();
   }
@@ skipping 115 matching lines @@
   void addLast(Element value) {
     throw new UnsupportedError('');
   }
 
   Iterator<Element> iterator() => new _FrozenElementListIterator(this);
 
   void addAll(Collection<Element> collection) {
     throw new UnsupportedError('');
   }
 
-  void sort([Comparator<Element> compare = Comparable.compare]) {
+  void sort([int compare(Element a, Element b)]) {
     throw new UnsupportedError('');
   }
 
   void setRange(int start, int rangeLength, List from, [int startFrom = 0]) {
     throw new UnsupportedError('');
   }
 
   void removeRange(int start, int rangeLength) {
     throw new UnsupportedError('');
   }
@@ skipping 1545 matching lines @@
      Collections.filter(this, <File>[], f);
 
   bool every(bool f(File element)) => Collections.every(this, f);
 
   bool some(bool f(File element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<File>:
 
-  void sort([Comparator<File> compare = Comparable.compare]) {
+  void sort([int compare(File a, File b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(File element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(File element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 372 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<num>:
 
-  void sort([Comparator<num> compare = Comparable.compare]) {
+  void sort([int compare(num a, num b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(num element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(num element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 120 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<num>:
 
-  void sort([Comparator<num> compare = Comparable.compare]) {
+  void sort([int compare(num a, num b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(num element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(num element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 548 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<Node>:
 
-  void sort([Comparator<Node> compare = Comparable.compare]) {
+  void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Node element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Node element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 100 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<Node>:
 
-  void sort([Comparator<Node> compare = Comparable.compare]) {
+  void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Node element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Node element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 1344 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<int>:
 
-  void sort([Comparator<int> compare = Comparable.compare]) {
+  void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 120 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<int>:
 
-  void sort([Comparator<int> compare = Comparable.compare]) {
+  void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 120 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<int>:
 
-  void sort([Comparator<int> compare = Comparable.compare]) {
+  void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 2836 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<Node>:
 
-  void sort([Comparator<Node> compare = Comparable.compare]) {
+  void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Node element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Node element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 248 matching lines @@
   bool every(bool f(Node element)) => Collections.every(this, f);
 
   bool some(bool f(Node element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<Node>:
 
   // TODO(jacobr): this could be implemented for child node lists.
   // The exception we throw here is misleading.
-  void sort([Comparator<Node> compare = Comparable.compare]) {
+  void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("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);
 
   // FIXME: implement these.
@@ skipping 351 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<Node>:
 
-  void sort([Comparator<Node> compare = Comparable.compare]) {
+  void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Node element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Node element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 2103 matching lines @@
      Collections.filter(this, <Map>[], f);
 
   bool every(bool f(Map element)) => Collections.every(this, f);
 
   bool some(bool f(Map element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<Map>:
 
-  void sort([Comparator<Map> compare = Comparable.compare]) {
+  void sort([int compare(Map a, Map b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Map element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Map element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 678 matching lines @@
      Collections.filter(this, <SourceBuffer>[], f);
 
   bool every(bool f(SourceBuffer element)) => Collections.every(this, f);
 
   bool some(bool f(SourceBuffer element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<SourceBuffer>:
 
-  void sort([Comparator<SourceBuffer> compare = Comparable.compare]) {
+  void sort([int compare(SourceBuffer a, SourceBuffer b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(SourceBuffer element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(SourceBuffer element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 188 matching lines @@
      Collections.filter(this, <SpeechGrammar>[], f);
 
   bool every(bool f(SpeechGrammar element)) => Collections.every(this, f);
 
   bool some(bool f(SpeechGrammar element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<SpeechGrammar>:
 
-  void sort([Comparator<SpeechGrammar> compare = Comparable.compare]) {
+  void sort([int compare(SpeechGrammar a, SpeechGrammar b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(SpeechGrammar element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(SpeechGrammar element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 1646 matching lines @@
      Collections.filter(this, <TextTrackCue>[], f);
 
   bool every(bool f(TextTrackCue element)) => Collections.every(this, f);
 
   bool some(bool f(TextTrackCue element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<TextTrackCue>:
 
-  void sort([Comparator<TextTrackCue> compare = Comparable.compare]) {
+  void sort([int compare(TextTrackCue a, TextTrackCue b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(TextTrackCue element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(TextTrackCue element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 100 matching lines @@
      Collections.filter(this, <TextTrack>[], f);
 
   bool every(bool f(TextTrack element)) => Collections.every(this, f);
 
   bool some(bool f(TextTrack element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<TextTrack>:
 
-  void sort([Comparator<TextTrack> compare = Comparable.compare]) {
+  void sort([int compare(TextTrack a, TextTrack b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(TextTrack element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(TextTrack element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 260 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<Touch>:
 
-  void sort([Comparator<Touch> compare = Comparable.compare]) {
+  void sort([int compare(Touch a, Touch b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Touch element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Touch element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 369 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<int>:
 
-  void sort([Comparator<int> compare = Comparable.compare]) {
+  void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 120 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<int>:
 
-  void sort([Comparator<int> compare = Comparable.compare]) {
+  void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 120 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<int>:
 
-  void sort([Comparator<int> compare = Comparable.compare]) {
+  void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 2633 matching lines @@
      Collections.filter(this, <CSSRule>[], f);
 
   bool every(bool f(CSSRule element)) => Collections.every(this, f);
 
   bool some(bool f(CSSRule element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<CSSRule>:
 
-  void sort([Comparator<CSSRule> compare = Comparable.compare]) {
+  void sort([int compare(CSSRule a, CSSRule b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(CSSRule element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(CSSRule element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 92 matching lines @@
      Collections.filter(this, <CSSValue>[], f);
 
   bool every(bool f(CSSValue element)) => Collections.every(this, f);
 
   bool some(bool f(CSSValue element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<CSSValue>:
 
-  void sort([Comparator<CSSValue> compare = Comparable.compare]) {
+  void sort([int compare(CSSValue a, CSSValue b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(CSSValue element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(CSSValue element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 92 matching lines @@
      Collections.filter(this, <ClientRect>[], f);
 
   bool every(bool f(ClientRect element)) => Collections.every(this, f);
 
   bool some(bool f(ClientRect element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<ClientRect>:
 
-  void sort([Comparator<ClientRect> compare = Comparable.compare]) {
+  void sort([int compare(ClientRect a, ClientRect b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(ClientRect element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(ClientRect element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 100 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<String>:
 
-  void sort([Comparator<String> compare = Comparable.compare]) {
+  void sort([int compare(String a, String b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(String element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(String element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 240 matching lines @@
      Collections.filter(this, <Entry>[], f);
 
   bool every(bool f(Entry element)) => Collections.every(this, f);
 
   bool some(bool f(Entry element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<Entry>:
 
-  void sort([Comparator<Entry> compare = Comparable.compare]) {
+  void sort([int compare(Entry a, Entry b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Entry element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Entry element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 92 matching lines @@
      Collections.filter(this, <EntrySync>[], f);
 
   bool every(bool f(EntrySync element)) => Collections.every(this, f);
 
   bool some(bool f(EntrySync element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<EntrySync>:
 
-  void sort([Comparator<EntrySync> compare = Comparable.compare]) {
+  void sort([int compare(EntrySync a, EntrySync b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(EntrySync element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(EntrySync element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 124 matching lines @@
      Collections.filter(this, <Gamepad>[], f);
 
   bool every(bool f(Gamepad element)) => Collections.every(this, f);
 
   bool some(bool f(Gamepad element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<Gamepad>:
 
-  void sort([Comparator<Gamepad> compare = Comparable.compare]) {
+  void sort([int compare(Gamepad a, Gamepad b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Gamepad element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Gamepad element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 141 matching lines @@
      Collections.filter(this, <MediaStream>[], f);
 
   bool every(bool f(MediaStream element)) => Collections.every(this, f);
 
   bool some(bool f(MediaStream element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<MediaStream>:
 
-  void sort([Comparator<MediaStream> compare = Comparable.compare]) {
+  void sort([int compare(MediaStream a, MediaStream b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(MediaStream element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(MediaStream element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 196 matching lines @@
      Collections.filter(this, <SpeechInputResult>[], f);
 
   bool every(bool f(SpeechInputResult element)) => Collections.every(this, f);
 
   bool some(bool f(SpeechInputResult element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<SpeechInputResult>:
 
-  void sort([Comparator<SpeechInputResult> compare = Comparable.compare]) {
+  void sort([int compare(SpeechInputResult a, SpeechInputResult b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(SpeechInputResult element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(SpeechInputResult element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 100 matching lines @@
      Collections.filter(this, <SpeechRecognitionResult>[], f);
 
   bool every(bool f(SpeechRecognitionResult element)) => Collections.every(this, f);
 
   bool some(bool f(SpeechRecognitionResult element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<SpeechRecognitionResult>:
 
-  void sort([Comparator<SpeechRecognitionResult> compare = Comparable.compare]) {
+  void sort([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(SpeechRecognitionResult element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(SpeechRecognitionResult element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 92 matching lines @@
      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 get isEmpty => this.length == 0;
 
   // From List<StyleSheet>:
 
-  void sort([Comparator<StyleSheet> compare = Comparable.compare]) {
+  void sort([int compare(StyleSheet a, StyleSheet b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(StyleSheet element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(StyleSheet element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 100 matching lines @@
      Collections.filter(this, <Animation>[], f);
 
   bool every(bool f(Animation element)) => Collections.every(this, f);
 
   bool some(bool f(Animation element)) => Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<Animation>:
 
-  void sort([Comparator<Animation> compare = Comparable.compare]) {
+  void sort([int compare(Animation a, Animation b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Animation element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Animation element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
@@ skipping 595 matching lines @@
   }
 
   void addLast(Element value) {
     add(value);
   }
 
   bool contains(Element element) {
     return element is Element && _childNodes.contains(element);
   }
 
-  void sort([Comparator<Element> compare = Comparable.compare]) {
+  void sort([int compare(Element a, Element b)]) {
     throw new UnsupportedError('TODO(jacobr): should we impl?');
   }
 
   void setRange(int start, int rangeLength, List from, [int startFrom = 0]) {
     throw new UnimplementedError();
   }
 
   void removeRange(int start, int rangeLength) {
     _filtered.getRange(start, rangeLength).forEach((el) => el.remove());
   }
@@ skipping 2397 matching lines @@
   bool get isEmpty => Maps.isEmpty(this);
 }
 
 get _printClosure => (s) {
   try {
     window.console.log(s);
   } catch (_) {
     _Utils.print(s);
   }
 };