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

sdk/lib/html/dart2js/html_dart2js.dart

 library html;
 
 import 'dart:collection';
 import 'dart:html_common';
 import 'dart:indexed_db';
 import 'dart:isolate';
 import 'dart:json';
 import 'dart:svg' as svg;
 import 'dart:web_audio' as web_audio;
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
@@ skipping 5514 matching lines @@
 
   /// @domName DirectoryReaderSync.readEntries; @docsEditable true
   @Returns('_EntryArraySync') @Creates('_EntryArraySync')
   List<EntrySync> readEntries() native;
 }
 // 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.
 
 
-/**
- * Represents an HTML <div> element.
- *
- * The [DivElement] is a generic container for content and does not have any
- * special significance. It is functionally similar to [SpanElement].
- *
- * The [DivElement] is a block-level element, as opposed to [SpanElement],
- * which is an inline-level element.
- *
- * Example usage:
- *
- *     DivElement div = new DivElement();
- *     div.text = 'Here's my new DivElem
- *     document.body.elements.add(elem);
- *
- * See also:
- *
- * * [HTML <div> element](http://www.w3.org/TR/html-markup/div.html) from W3C.
- * * [Block-level element](http://www.w3.org/TR/CSS2/visuren.html#block-boxes) from W3C.
- * * [Inline-level element](http://www.w3.org/TR/CSS2/visuren.html#inline-boxes) from W3C.
- */
 /// @domName HTMLDivElement; @docsEditable true
 class DivElement extends Element implements Element native "*HTMLDivElement" {
 
   factory DivElement() => document.$dom_createElement("div");
 }
 // 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.
 
 
@@ skipping 18 matching lines @@
   /// @domName Document.body; @docsEditable true
   @JSName('body')
   Element $dom_body;
 
   /// @domName Document.charset; @docsEditable true
   String charset;
 
   /// @domName Document.cookie; @docsEditable true
   String cookie;
 
-  /// Returns the [Window] associated with the document.
   /// @domName Document.defaultView; @docsEditable true
   Window get window => _convertNativeToDart_Window(this._window);
   @JSName('defaultView')
   @Creates('LocalWindow|=Object') @Returns('LocalWindow|=Object')
   final dynamic _window;
 
   /// @domName Document.documentElement; @docsEditable true
   final Element documentElement;
 
   /// @domName Document.domain; @docsEditable true
@@ skipping 737 matching lines @@
 
   // From List<DomMimeType>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 135 matching lines @@
 
   // From List<DomPlugin>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 196 matching lines @@
 
   // From List<String>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 161 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 compare = Comparable.compare]) {
+  void sort([int compare(Element a, Element b)]) {
     throw new UnsupportedError('TODO(jacobr): should we impl?');
   }
 
   dynamic reduce(dynamic initialValue,
       dynamic combine(dynamic previousValue, Element element)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   void setRange(int start, int rangeLength, List from, [int startFrom = 0]) {
     throw new UnimplementedError();
@@ skipping 128 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 compare = Comparable.compare]) {
+  void sort([int compare(Element a, Element b)]) {
     throw new UnsupportedError('');
   }
 
   dynamic reduce(dynamic initialValue,
       dynamic combine(dynamic previousValue, Element element)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   void setRange(int start, int rangeLength, List from, [int startFrom = 0]) {
     throw new UnsupportedError('');
@@ skipping 1374 matching lines @@
 
   // From List<File>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 335 matching lines @@
 
   // From List<num>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 105 matching lines @@
 
   // From List<num>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 407 matching lines @@
 
   // From List<Node>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 @@
 
   // From List<Node>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 777 matching lines @@
 
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 105 matching lines @@
 
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 105 matching lines @@
 
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 1653 matching lines @@
   final int totalJSHeapSize;
 
   /// @domName MemoryInfo.usedJSHeapSize; @docsEditable true
   final int usedJSHeapSize;
 }
 // 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.
 
 
-/**
- * An HTML <menu> element.
- *
- * A <menu> element represents an unordered list of menu commands.
- *
- * See also:
- *
- *  * [Menu Element](https://developer.mozilla.org/en-US/docs/HTML/Element/menu) from MDN.
- *  * [Menu Element](http://www.w3.org/TR/html5/the-menu-element.html#the-menu-element) from the W3C.
- */
 /// @domName HTMLMenuElement; @docsEditable true
 class MenuElement extends Element implements Element native "*HTMLMenuElement" {
 
   factory MenuElement() => document.$dom_createElement("menu");
 }
 // 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.
 
 
@@ skipping 521 matching lines @@
 
   // From List<Node>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 240 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 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 333 matching lines @@
 
   // From List<Node>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 1892 matching lines @@
 
   // From List<SourceBuffer>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 152 matching lines @@
 
   // From List<SpeechGrammar>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 363 matching lines @@
 
   // From List<Map>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 867 matching lines @@
 
   // From List<TextTrackCue>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 @@
 
   // From List<TextTrack>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 225 matching lines @@
 
   // From List<Touch>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 285 matching lines @@
 
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 105 matching lines @@
 
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 105 matching lines @@
 
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 2181 matching lines @@
 
   // From List<ClientRect>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 102 matching lines @@
 
   // From List<CssRule>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 93 matching lines @@
 
   // From List<CssValue>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 119 matching lines @@
 
   // From List<Entry>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 93 matching lines @@
 
   // From List<EntrySync>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 131 matching lines @@
 
   // From List<Gamepad>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 146 matching lines @@
 
   // From List<MediaStream>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 246 matching lines @@
 
   // From List<SpeechInputResult>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 102 matching lines @@
 
   // From List<SpeechRecognitionResult>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 93 matching lines @@
 
   // From List<StyleSheet>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 117 matching lines @@
 
   // From List<Animation>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
-  void sort([Comparator 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 633 matching lines @@
   }
 
   void addLast(Element value) {
     add(value);
   }
 
   bool contains(Element element) {
     return element is Element && _childNodes.contains(element);
   }
 
-  void sort([Comparator 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 2558 matching lines @@
   T next() {
     if (!hasNext) {
       throw new StateError("No more elements");
     }
     return _array[_pos++];
   }
 
   final List<T> _array;
   int _pos;
 }