Fixes for a number of dart analyzer issues in dart:html.

sdk/lib/svg/dart2js/svg_dart2js.dart

 library svg;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'dart:html_common';
 // DO NOT EDIT
 // Auto-generated dart:svg library.
 
 
@@ skipping 2967 matching lines @@
   String join([String separator]) => Collections.joinList(this, separator);
 
   List mappedBy(f(Length element)) => new MappedList<Length, dynamic>(this, f);
 
   Iterable<Length> where(bool f(Length element)) => new WhereIterable<Length>(this, f);
 
   bool every(bool f(Length element)) => Collections.every(this, f);
 
   bool any(bool f(Length element)) => Collections.any(this, f);
 
+  List<Length> toList() => new List<Length>.from(this);
+  Set<Length> toSet() => new Set<Length>.from(this);
+
   bool get isEmpty => this.length == 0;
 
   List<Length> take(int n) => new ListView<Length>(this, 0, n);
 
   Iterable<Length> takeWhile(bool test(Length value)) {
     return new TakeWhileIterable<Length>(this, test);
   }
 
   List<Length> skip(int n) => new ListView<Length>(this, n, null);
 
@@ skipping 59 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   Length get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  Length min([int compare(Length a, Length b)]) => _Collections.minInList(this, compare);
+  Length min([int compare(Length a, Length b)]) => Collections.min(this, compare);
 
-  Length max([int compare(Length a, Length b)]) => _Collections.maxInList(this, compare);
+  Length max([int compare(Length a, Length b)]) => Collections.max(this, compare);
 
   Length removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Length removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Length> from, [int startFrom]) {
@@ skipping 469 matching lines @@
   String join([String separator]) => Collections.joinList(this, separator);
 
   List mappedBy(f(Number element)) => new MappedList<Number, dynamic>(this, f);
 
   Iterable<Number> where(bool f(Number element)) => new WhereIterable<Number>(this, f);
 
   bool every(bool f(Number element)) => Collections.every(this, f);
 
   bool any(bool f(Number element)) => Collections.any(this, f);
 
+  List<Number> toList() => new List<Number>.from(this);
+  Set<Number> toSet() => new Set<Number>.from(this);
+
   bool get isEmpty => this.length == 0;
 
   List<Number> take(int n) => new ListView<Number>(this, 0, n);
 
   Iterable<Number> takeWhile(bool test(Number value)) {
     return new TakeWhileIterable<Number>(this, test);
   }
 
   List<Number> skip(int n) => new ListView<Number>(this, n, null);
 
@@ skipping 59 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   Number get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  Number min([int compare(Number a, Number b)]) => _Collections.minInList(this, compare);
+  Number min([int compare(Number a, Number b)]) => Collections.min(this, compare);
 
-  Number max([int compare(Number a, Number b)]) => _Collections.maxInList(this, compare);
+  Number max([int compare(Number a, Number b)]) => Collections.max(this, compare);
 
   Number removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Number removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Number> from, [int startFrom]) {
@@ skipping 644 matching lines @@
   String join([String separator]) => Collections.joinList(this, separator);
 
   List mappedBy(f(PathSeg element)) => new MappedList<PathSeg, dynamic>(this, f);
 
   Iterable<PathSeg> where(bool f(PathSeg element)) => new WhereIterable<PathSeg>(this, f);
 
   bool every(bool f(PathSeg element)) => Collections.every(this, f);
 
   bool any(bool f(PathSeg element)) => Collections.any(this, f);
 
+  List<PathSeg> toList() => new List<PathSeg>.from(this);
+  Set<PathSeg> toSet() => new Set<PathSeg>.from(this);
+
   bool get isEmpty => this.length == 0;
 
   List<PathSeg> take(int n) => new ListView<PathSeg>(this, 0, n);
 
   Iterable<PathSeg> takeWhile(bool test(PathSeg value)) {
     return new TakeWhileIterable<PathSeg>(this, test);
   }
 
   List<PathSeg> skip(int n) => new ListView<PathSeg>(this, n, null);
 
@@ skipping 59 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   PathSeg get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  PathSeg min([int compare(PathSeg a, PathSeg b)]) => _Collections.minInList(this, compare);
+  PathSeg min([int compare(PathSeg a, PathSeg b)]) => Collections.min(this, compare);
 
-  PathSeg max([int compare(PathSeg a, PathSeg b)]) => _Collections.maxInList(this, compare);
+  PathSeg max([int compare(PathSeg a, PathSeg b)]) => Collections.max(this, compare);
 
   PathSeg removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   PathSeg removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<PathSeg> from, [int startFrom]) {
@@ skipping 669 matching lines @@
   String join([String separator]) => Collections.joinList(this, separator);
 
   List mappedBy(f(String element)) => new MappedList<String, dynamic>(this, f);
 
   Iterable<String> where(bool f(String element)) => new WhereIterable<String>(this, f);
 
   bool every(bool f(String element)) => Collections.every(this, f);
 
   bool any(bool f(String element)) => Collections.any(this, f);
 
+  List<String> toList() => new List<String>.from(this);
+  Set<String> toSet() => new Set<String>.from(this);
+
   bool get isEmpty => this.length == 0;
 
   List<String> take(int n) => new ListView<String>(this, 0, n);
 
   Iterable<String> takeWhile(bool test(String value)) {
     return new TakeWhileIterable<String>(this, test);
   }
 
   List<String> skip(int n) => new ListView<String>(this, n, null);
 
@@ skipping 59 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   String get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  String min([int compare(String a, String b)]) => _Collections.minInList(this, compare);
+  String min([int compare(String a, String b)]) => Collections.min(this, compare);
 
-  String max([int compare(String a, String b)]) => _Collections.maxInList(this, compare);
+  String max([int compare(String a, String b)]) => Collections.max(this, compare);
 
   String removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   String removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<String> from, [int startFrom]) {
@@ skipping 937 matching lines @@
   String join([String separator]) => Collections.joinList(this, separator);
 
   List mappedBy(f(Transform element)) => new MappedList<Transform, dynamic>(this, f);
 
   Iterable<Transform> where(bool f(Transform element)) => new WhereIterable<Transform>(this, f);
 
   bool every(bool f(Transform element)) => Collections.every(this, f);
 
   bool any(bool f(Transform element)) => Collections.any(this, f);
 
+  List<Transform> toList() => new List<Transform>.from(this);
+  Set<Transform> toSet() => new Set<Transform>.from(this);
+
   bool get isEmpty => this.length == 0;
 
   List<Transform> take(int n) => new ListView<Transform>(this, 0, n);
 
   Iterable<Transform> takeWhile(bool test(Transform value)) {
     return new TakeWhileIterable<Transform>(this, test);
   }
 
   List<Transform> skip(int n) => new ListView<Transform>(this, n, null);
 
@@ skipping 59 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   Transform get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  Transform min([int compare(Transform a, Transform b)]) => _Collections.minInList(this, compare);
+  Transform min([int compare(Transform a, Transform b)]) => Collections.min(this, compare);
 
-  Transform max([int compare(Transform a, Transform b)]) => _Collections.maxInList(this, compare);
+  Transform max([int compare(Transform a, Transform b)]) => Collections.max(this, compare);
 
   Transform removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Transform removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Transform> from, [int startFrom]) {
@@ skipping 349 matching lines @@
   String join([String separator]) => Collections.joinList(this, separator);
 
   List mappedBy(f(ElementInstance element)) => new MappedList<ElementInstance, dynamic>(this, f);
 
   Iterable<ElementInstance> where(bool f(ElementInstance element)) => new WhereIterable<ElementInstance>(this, f);
 
   bool every(bool f(ElementInstance element)) => Collections.every(this, f);
 
   bool any(bool f(ElementInstance element)) => Collections.any(this, f);
 
+  List<ElementInstance> toList() => new List<ElementInstance>.from(this);
+  Set<ElementInstance> toSet() => new Set<ElementInstance>.from(this);
+
   bool get isEmpty => this.length == 0;
 
   List<ElementInstance> take(int n) => new ListView<ElementInstance>(this, 0, n);
 
   Iterable<ElementInstance> takeWhile(bool test(ElementInstance value)) {
     return new TakeWhileIterable<ElementInstance>(this, test);
   }
 
   List<ElementInstance> skip(int n) => new ListView<ElementInstance>(this, n, null);
 
@@ skipping 61 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   ElementInstance get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  ElementInstance min([int compare(ElementInstance a, ElementInstance b)]) => _Collections.minInList(this, compare);
+  ElementInstance min([int compare(ElementInstance a, ElementInstance b)]) => Collections.min(this, compare);
 
-  ElementInstance max([int compare(ElementInstance a, ElementInstance b)]) => _Collections.maxInList(this, compare);
+  ElementInstance max([int compare(ElementInstance a, ElementInstance b)]) => Collections.max(this, compare);
 
   ElementInstance removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   ElementInstance removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<ElementInstance> from, [int startFrom]) {
     throw new UnsupportedError("Cannot setRange on immutable List.");
   }
 
   void removeRange(int start, int rangeLength) {
     throw new UnsupportedError("Cannot removeRange on immutable List.");
   }
 
   void insertRange(int start, int rangeLength, [ElementInstance initialValue]) {
     throw new UnsupportedError("Cannot insertRange on immutable List.");
   }
 
   List<ElementInstance> getRange(int start, int rangeLength) =>
       Lists.getRange(this, start, rangeLength, <ElementInstance>[]);
 
   // -- end List<ElementInstance> mixins.
 
   /// @domName SVGElementInstanceList.item; @docsEditable true
   ElementInstance item(int index) native;
 }