sdk/lib/html/dartium/html_dartium.dart - Issue 12036071: Fixing analyzer issues in DOM libs.

Unified Diff: sdk/lib/html/dartium/html_dartium.dart

Issue 12036071: Fixing analyzer issues in DOM libs. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart

Patch Set: Created 7 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

Download patch

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 00b5561c741412e7f87a21231e1125a84d713d19..7271a14392565b93ce603e93316f81e14ec207fe 100644

--- a/sdk/lib/html/dartium/html_dartium.dart

+++ b/sdk/lib/html/dartium/html_dartium.dart

@@ -2,6 +2,7 @@ library html;

import 'dart:async';

import 'dart:collection';

+import 'dart:collection-dev';

import 'dart:html_common';

import 'dart:indexed_db';

import 'dart:isolate';

@@ -7886,11 +7887,13 @@ class DomMimeTypeArray extends NativeFieldWrapperClass1 implements List<DomMimeT

void forEach(void f(DomMimeType element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(DomMimeType element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<DomMimeType> where(bool f(DomMimeType element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<DomMimeType> where(bool f(DomMimeType element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(DomMimeType element)) => IterableMixinWorkaround.every(this, f);

@@ -7952,6 +7955,9 @@ class DomMimeTypeArray extends NativeFieldWrapperClass1 implements List<DomMimeT

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<DomMimeType> get reversed =>

+ new ReversedListView<DomMimeType>(this, 0, null);

void sort([int compare(DomMimeType a, DomMimeType b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -7980,9 +7986,11 @@ class DomMimeTypeArray extends NativeFieldWrapperClass1 implements List<DomMimeT

throw new StateError("More than one element");

}

- DomMimeType min([int compare(DomMimeType a, DomMimeType b)]) => IterableMixinWorkaround.min(this, compare);

+ DomMimeType min([int compare(DomMimeType a, DomMimeType b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- DomMimeType max([int compare(DomMimeType a, DomMimeType b)]) => IterableMixinWorkaround.max(this, compare);

+ DomMimeType max([int compare(DomMimeType a, DomMimeType b)]) =>

+ IterableMixinWorkaround.max(this, compare);

DomMimeType removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -8137,11 +8145,13 @@ class DomPluginArray extends NativeFieldWrapperClass1 implements List<DomPlugin>

void forEach(void f(DomPlugin element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(DomPlugin element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<DomPlugin> where(bool f(DomPlugin element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<DomPlugin> where(bool f(DomPlugin element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(DomPlugin element)) => IterableMixinWorkaround.every(this, f);

@@ -8203,6 +8213,9 @@ class DomPluginArray extends NativeFieldWrapperClass1 implements List<DomPlugin>

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<DomPlugin> get reversed =>

+ new ReversedListView<DomPlugin>(this, 0, null);

void sort([int compare(DomPlugin a, DomPlugin b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -8231,9 +8244,11 @@ class DomPluginArray extends NativeFieldWrapperClass1 implements List<DomPlugin>

throw new StateError("More than one element");

}

- DomPlugin min([int compare(DomPlugin a, DomPlugin b)]) => IterableMixinWorkaround.min(this, compare);

+ DomPlugin min([int compare(DomPlugin a, DomPlugin b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- DomPlugin max([int compare(DomPlugin a, DomPlugin b)]) => IterableMixinWorkaround.max(this, compare);

+ DomPlugin max([int compare(DomPlugin a, DomPlugin b)]) =>

+ IterableMixinWorkaround.max(this, compare);

DomPlugin removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -8472,11 +8487,13 @@ class DomStringList extends NativeFieldWrapperClass1 implements List<String> {

void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(String element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<String> where(bool f(String element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<String> where(bool f(String element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f);

@@ -8538,6 +8555,9 @@ class DomStringList extends NativeFieldWrapperClass1 implements List<String> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<String> get reversed =>

+ new ReversedListView<String>(this, 0, null);

void sort([int compare(String a, String b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -8566,9 +8586,11 @@ class DomStringList extends NativeFieldWrapperClass1 implements List<String> {

throw new StateError("More than one element");

}

- String min([int compare(String a, String b)]) => IterableMixinWorkaround.min(this, compare);

+ String min([int compare(String a, String b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- String max([int compare(String a, String b)]) => IterableMixinWorkaround.max(this, compare);

+ String max([int compare(String a, String b)]) =>

+ IterableMixinWorkaround.max(this, compare);

String removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -8819,6 +8841,9 @@ class _ChildrenElementList implements List {

}

+ List<Element> get reversed =>

+ new ReversedListView<Element>(this, 0, null);

void sort([int compare(Element a, Element b)]) {

throw new UnsupportedError('TODO(jacobr): should we impl?');

}

@@ -8842,19 +8867,19 @@ class _ChildrenElementList implements List {

}

void removeAll(Iterable elements) {

- Collections.removeAll(this, elements);

+ IterableMixinWorkaround.removeAll(this, elements);

}

void retainAll(Iterable elements) {

- Collections.retainAll(this, elements);

+ IterableMixinWorkaround.retainAll(this, elements);

}

void removeMatching(bool test(Element element)) {

- Collections.removeMatching(this, test);

+ IterableMixinWorkaround.removeMatching(this, test);

}

void retainMatching(bool test(Element element)) {

- Collections.retainMatching(this, test);

+ IterableMixinWorkaround.retainMatching(this, test);

}

void removeRange(int start, int rangeLength) {

@@ -9041,6 +9066,9 @@ class _FrozenElementList implements List {

throw new UnsupportedError('');

}

+ List<Element> get reversed =>

+ new ReversedListView<Element>(this, 0, null);

void sort([int compare(Element a, Element b)]) {

throw new UnsupportedError('');

}

@@ -11372,11 +11400,13 @@ class FileList extends NativeFieldWrapperClass1 implements List<File> {

void forEach(void f(File element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(File element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<File> where(bool f(File element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<File> where(bool f(File element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(File element)) => IterableMixinWorkaround.every(this, f);

@@ -11438,6 +11468,9 @@ class FileList extends NativeFieldWrapperClass1 implements List<File> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<File> get reversed =>

+ new ReversedListView<File>(this, 0, null);

void sort([int compare(File a, File b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -11466,9 +11499,11 @@ class FileList extends NativeFieldWrapperClass1 implements List<File> {

throw new StateError("More than one element");

}

- File min([int compare(File a, File b)]) => IterableMixinWorkaround.min(this, compare);

+ File min([int compare(File a, File b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- File max([int compare(File a, File b)]) => IterableMixinWorkaround.max(this, compare);

+ File max([int compare(File a, File b)]) =>

+ IterableMixinWorkaround.max(this, compare);

File removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -12008,11 +12043,13 @@ class Float32Array extends ArrayBufferView implements List<num> {

void forEach(void f(num element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(num element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<num> where(bool f(num element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<num> where(bool f(num element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(num element)) => IterableMixinWorkaround.every(this, f);

@@ -12074,6 +12111,9 @@ class Float32Array extends ArrayBufferView implements List<num> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<num> get reversed =>

+ new ReversedListView<num>(this, 0, null);

void sort([int compare(num a, num b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -12102,9 +12142,11 @@ class Float32Array extends ArrayBufferView implements List<num> {

throw new StateError("More than one element");

}

- num min([int compare(num a, num b)]) => IterableMixinWorkaround.min(this, compare);

+ num min([int compare(num a, num b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- num max([int compare(num a, num b)]) => IterableMixinWorkaround.max(this, compare);

+ num max([int compare(num a, num b)]) =>

+ IterableMixinWorkaround.max(this, compare);

num removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -12225,11 +12267,13 @@ class Float64Array extends ArrayBufferView implements List<num> {

void forEach(void f(num element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(num element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<num> where(bool f(num element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<num> where(bool f(num element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(num element)) => IterableMixinWorkaround.every(this, f);

@@ -12291,6 +12335,9 @@ class Float64Array extends ArrayBufferView implements List<num> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<num> get reversed =>

+ new ReversedListView<num>(this, 0, null);

void sort([int compare(num a, num b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -12319,9 +12366,11 @@ class Float64Array extends ArrayBufferView implements List<num> {

throw new StateError("More than one element");

}

- num min([int compare(num a, num b)]) => IterableMixinWorkaround.min(this, compare);

+ num min([int compare(num a, num b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- num max([int compare(num a, num b)]) => IterableMixinWorkaround.max(this, compare);

+ num max([int compare(num a, num b)]) =>

+ IterableMixinWorkaround.max(this, compare);

num removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -12794,11 +12843,13 @@ class HtmlAllCollection extends NativeFieldWrapperClass1 implements List<Node> {

void forEach(void f(Node element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(Node element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<Node> where(bool f(Node element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<Node> where(bool f(Node element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(Node element)) => IterableMixinWorkaround.every(this, f);

@@ -12860,6 +12911,9 @@ class HtmlAllCollection extends NativeFieldWrapperClass1 implements List<Node> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<Node> get reversed =>

+ new ReversedListView<Node>(this, 0, null);

void sort([int compare(Node a, Node b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -12888,9 +12942,11 @@ class HtmlAllCollection extends NativeFieldWrapperClass1 implements List<Node> {

throw new StateError("More than one element");

}

- Node min([int compare(Node a, Node b)]) => IterableMixinWorkaround.min(this, compare);

+ Node min([int compare(Node a, Node b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- Node max([int compare(Node a, Node b)]) => IterableMixinWorkaround.max(this, compare);

+ Node max([int compare(Node a, Node b)]) =>

+ IterableMixinWorkaround.max(this, compare);

Node removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -12991,11 +13047,13 @@ class HtmlCollection extends NativeFieldWrapperClass1 implements List<Node> {

void forEach(void f(Node element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(Node element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<Node> where(bool f(Node element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<Node> where(bool f(Node element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(Node element)) => IterableMixinWorkaround.every(this, f);

@@ -13057,6 +13115,9 @@ class HtmlCollection extends NativeFieldWrapperClass1 implements List<Node> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<Node> get reversed =>

+ new ReversedListView<Node>(this, 0, null);

void sort([int compare(Node a, Node b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -13085,9 +13146,11 @@ class HtmlCollection extends NativeFieldWrapperClass1 implements List<Node> {

throw new StateError("More than one element");

}

- Node min([int compare(Node a, Node b)]) => IterableMixinWorkaround.min(this, compare);

+ Node min([int compare(Node a, Node b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- Node max([int compare(Node a, Node b)]) => IterableMixinWorkaround.max(this, compare);

+ Node max([int compare(Node a, Node b)]) =>

+ IterableMixinWorkaround.max(this, compare);

Node removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -15077,11 +15140,13 @@ class Int16Array extends ArrayBufferView implements List<int> {

void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<int> where(bool f(int element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);

@@ -15143,6 +15208,9 @@ class Int16Array extends ArrayBufferView implements List<int> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<int> get reversed =>

+ new ReversedListView<int>(this, 0, null);

void sort([int compare(int a, int b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -15171,9 +15239,11 @@ class Int16Array extends ArrayBufferView implements List<int> {

throw new StateError("More than one element");

}

- int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);

+ int min([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);

+ int max([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.max(this, compare);

int removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -15294,11 +15364,13 @@ class Int32Array extends ArrayBufferView implements List<int> {

void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<int> where(bool f(int element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);

@@ -15360,6 +15432,9 @@ class Int32Array extends ArrayBufferView implements List<int> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<int> get reversed =>

+ new ReversedListView<int>(this, 0, null);

void sort([int compare(int a, int b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -15388,9 +15463,11 @@ class Int32Array extends ArrayBufferView implements List<int> {

throw new StateError("More than one element");

}

- int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);

+ int min([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);

+ int max([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.max(this, compare);

int removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -15511,11 +15588,13 @@ class Int8Array extends ArrayBufferView implements List<int> {

void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<int> where(bool f(int element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);

@@ -15577,6 +15656,9 @@ class Int8Array extends ArrayBufferView implements List<int> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<int> get reversed =>

+ new ReversedListView<int>(this, 0, null);

void sort([int compare(int a, int b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -15605,9 +15687,11 @@ class Int8Array extends ArrayBufferView implements List<int> {

throw new StateError("More than one element");

}

- int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);

+ int min([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);

+ int max([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.max(this, compare);

int removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -18058,11 +18142,13 @@ class NamedNodeMap extends NativeFieldWrapperClass1 implements List<Node> {

void forEach(void f(Node element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(Node element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<Node> where(bool f(Node element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<Node> where(bool f(Node element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(Node element)) => IterableMixinWorkaround.every(this, f);

@@ -18124,6 +18210,9 @@ class NamedNodeMap extends NativeFieldWrapperClass1 implements List<Node> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<Node> get reversed =>

+ new ReversedListView<Node>(this, 0, null);

void sort([int compare(Node a, Node b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -18152,9 +18241,11 @@ class NamedNodeMap extends NativeFieldWrapperClass1 implements List<Node> {

throw new StateError("More than one element");

}

- Node min([int compare(Node a, Node b)]) => IterableMixinWorkaround.min(this, compare);

+ Node min([int compare(Node a, Node b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- Node max([int compare(Node a, Node b)]) => IterableMixinWorkaround.max(this, compare);

+ Node max([int compare(Node a, Node b)]) =>

+ IterableMixinWorkaround.max(this, compare);

Node removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -18567,6 +18658,9 @@ class _ChildNodeListLazy implements List {

return this[index];

}

+ List<Node> get reversed =>

+ new ReversedListView<Node>(this, 0, null);

// TODO(jacobr): this could be implemented for child node lists.

// The exception we throw here is misleading.

void sort([int compare(Node a, Node b)]) {

@@ -18894,11 +18988,13 @@ class NodeList extends NativeFieldWrapperClass1 implements List<Node> {

void forEach(void f(Node element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(Node element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<Node> where(bool f(Node element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<Node> where(bool f(Node element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(Node element)) => IterableMixinWorkaround.every(this, f);

@@ -18960,6 +19056,9 @@ class NodeList extends NativeFieldWrapperClass1 implements List<Node> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<Node> get reversed =>

+ new ReversedListView<Node>(this, 0, null);

void sort([int compare(Node a, Node b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -18988,9 +19087,11 @@ class NodeList extends NativeFieldWrapperClass1 implements List<Node> {

throw new StateError("More than one element");

}

- Node min([int compare(Node a, Node b)]) => IterableMixinWorkaround.min(this, compare);

+ Node min([int compare(Node a, Node b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- Node max([int compare(Node a, Node b)]) => IterableMixinWorkaround.max(this, compare);

+ Node max([int compare(Node a, Node b)]) =>

+ IterableMixinWorkaround.max(this, compare);

Node removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -21608,11 +21709,13 @@ class SourceBufferList extends EventTarget implements List<SourceBuffer> {

void forEach(void f(SourceBuffer element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(SourceBuffer element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<SourceBuffer> where(bool f(SourceBuffer element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<SourceBuffer> where(bool f(SourceBuffer element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(SourceBuffer element)) => IterableMixinWorkaround.every(this, f);

@@ -21674,6 +21777,9 @@ class SourceBufferList extends EventTarget implements List<SourceBuffer> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<SourceBuffer> get reversed =>

+ new ReversedListView<SourceBuffer>(this, 0, null);

void sort([int compare(SourceBuffer a, SourceBuffer b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -21702,9 +21808,11 @@ class SourceBufferList extends EventTarget implements List<SourceBuffer> {

throw new StateError("More than one element");

}

- SourceBuffer min([int compare(SourceBuffer a, SourceBuffer b)]) => IterableMixinWorkaround.min(this, compare);

+ SourceBuffer min([int compare(SourceBuffer a, SourceBuffer b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- SourceBuffer max([int compare(SourceBuffer a, SourceBuffer b)]) => IterableMixinWorkaround.max(this, compare);

+ SourceBuffer max([int compare(SourceBuffer a, SourceBuffer b)]) =>

+ IterableMixinWorkaround.max(this, compare);

SourceBuffer removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -21902,11 +22010,13 @@ class SpeechGrammarList extends NativeFieldWrapperClass1 implements List<SpeechG

void forEach(void f(SpeechGrammar element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(SpeechGrammar element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<SpeechGrammar> where(bool f(SpeechGrammar element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<SpeechGrammar> where(bool f(SpeechGrammar element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(SpeechGrammar element)) => IterableMixinWorkaround.every(this, f);

@@ -21968,6 +22078,9 @@ class SpeechGrammarList extends NativeFieldWrapperClass1 implements List<SpeechG

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<SpeechGrammar> get reversed =>

+ new ReversedListView<SpeechGrammar>(this, 0, null);

void sort([int compare(SpeechGrammar a, SpeechGrammar b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -21996,9 +22109,11 @@ class SpeechGrammarList extends NativeFieldWrapperClass1 implements List<SpeechG

throw new StateError("More than one element");

}

- SpeechGrammar min([int compare(SpeechGrammar a, SpeechGrammar b)]) => IterableMixinWorkaround.min(this, compare);

+ SpeechGrammar min([int compare(SpeechGrammar a, SpeechGrammar b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- SpeechGrammar max([int compare(SpeechGrammar a, SpeechGrammar b)]) => IterableMixinWorkaround.max(this, compare);

+ SpeechGrammar max([int compare(SpeechGrammar a, SpeechGrammar b)]) =>

+ IterableMixinWorkaround.max(this, compare);

SpeechGrammar removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -22582,11 +22697,13 @@ class SqlResultSetRowList extends NativeFieldWrapperClass1 implements List<Map>

void forEach(void f(Map element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(Map element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<Map> where(bool f(Map element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<Map> where(bool f(Map element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(Map element)) => IterableMixinWorkaround.every(this, f);

@@ -22648,6 +22765,9 @@ class SqlResultSetRowList extends NativeFieldWrapperClass1 implements List<Map>

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<Map> get reversed =>

+ new ReversedListView<Map>(this, 0, null);

void sort([int compare(Map a, Map b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -22676,9 +22796,11 @@ class SqlResultSetRowList extends NativeFieldWrapperClass1 implements List<Map>

throw new StateError("More than one element");

}

- Map min([int compare(Map a, Map b)]) => IterableMixinWorkaround.min(this, compare);

+ Map min([int compare(Map a, Map b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- Map max([int compare(Map a, Map b)]) => IterableMixinWorkaround.max(this, compare);

+ Map max([int compare(Map a, Map b)]) =>

+ IterableMixinWorkaround.max(this, compare);

Map removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -23876,11 +23998,13 @@ class TextTrackCueList extends NativeFieldWrapperClass1 implements List<TextTrac

void forEach(void f(TextTrackCue element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(TextTrackCue element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<TextTrackCue> where(bool f(TextTrackCue element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<TextTrackCue> where(bool f(TextTrackCue element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(TextTrackCue element)) => IterableMixinWorkaround.every(this, f);

@@ -23942,6 +24066,9 @@ class TextTrackCueList extends NativeFieldWrapperClass1 implements List<TextTrac

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<TextTrackCue> get reversed =>

+ new ReversedListView<TextTrackCue>(this, 0, null);

void sort([int compare(TextTrackCue a, TextTrackCue b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -23970,9 +24097,11 @@ class TextTrackCueList extends NativeFieldWrapperClass1 implements List<TextTrac

throw new StateError("More than one element");

}

- TextTrackCue min([int compare(TextTrackCue a, TextTrackCue b)]) => IterableMixinWorkaround.min(this, compare);

+ TextTrackCue min([int compare(TextTrackCue a, TextTrackCue b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- TextTrackCue max([int compare(TextTrackCue a, TextTrackCue b)]) => IterableMixinWorkaround.max(this, compare);

+ TextTrackCue max([int compare(TextTrackCue a, TextTrackCue b)]) =>

+ IterableMixinWorkaround.max(this, compare);

TextTrackCue removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -24078,11 +24207,13 @@ class TextTrackList extends EventTarget implements List<TextTrack> {

void forEach(void f(TextTrack element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(TextTrack element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<TextTrack> where(bool f(TextTrack element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<TextTrack> where(bool f(TextTrack element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(TextTrack element)) => IterableMixinWorkaround.every(this, f);

@@ -24144,6 +24275,9 @@ class TextTrackList extends EventTarget implements List<TextTrack> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<TextTrack> get reversed =>

+ new ReversedListView<TextTrack>(this, 0, null);

void sort([int compare(TextTrack a, TextTrack b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -24172,9 +24306,11 @@ class TextTrackList extends EventTarget implements List<TextTrack> {

throw new StateError("More than one element");

}

- TextTrack min([int compare(TextTrack a, TextTrack b)]) => IterableMixinWorkaround.min(this, compare);

+ TextTrack min([int compare(TextTrack a, TextTrack b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- TextTrack max([int compare(TextTrack a, TextTrack b)]) => IterableMixinWorkaround.max(this, compare);

+ TextTrack max([int compare(TextTrack a, TextTrack b)]) =>

+ IterableMixinWorkaround.max(this, compare);

TextTrack removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -24459,11 +24595,13 @@ class TouchList extends NativeFieldWrapperClass1 implements List<Touch> {

void forEach(void f(Touch element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(Touch element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<Touch> where(bool f(Touch element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<Touch> where(bool f(Touch element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(Touch element)) => IterableMixinWorkaround.every(this, f);

@@ -24525,6 +24663,9 @@ class TouchList extends NativeFieldWrapperClass1 implements List<Touch> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<Touch> get reversed =>

+ new ReversedListView<Touch>(this, 0, null);

void sort([int compare(Touch a, Touch b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -24553,9 +24694,11 @@ class TouchList extends NativeFieldWrapperClass1 implements List<Touch> {

throw new StateError("More than one element");

}

- Touch min([int compare(Touch a, Touch b)]) => IterableMixinWorkaround.min(this, compare);

+ Touch min([int compare(Touch a, Touch b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- Touch max([int compare(Touch a, Touch b)]) => IterableMixinWorkaround.max(this, compare);

+ Touch max([int compare(Touch a, Touch b)]) =>

+ IterableMixinWorkaround.max(this, compare);

Touch removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -24926,11 +25069,13 @@ class Uint16Array extends ArrayBufferView implements List<int> {

void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<int> where(bool f(int element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);

@@ -24992,6 +25137,9 @@ class Uint16Array extends ArrayBufferView implements List<int> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<int> get reversed =>

+ new ReversedListView<int>(this, 0, null);

void sort([int compare(int a, int b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -25020,9 +25168,11 @@ class Uint16Array extends ArrayBufferView implements List<int> {

throw new StateError("More than one element");

}

- int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);

+ int min([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);

+ int max([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.max(this, compare);

int removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -25143,11 +25293,13 @@ class Uint32Array extends ArrayBufferView implements List<int> {

void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<int> where(bool f(int element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);

@@ -25209,6 +25361,9 @@ class Uint32Array extends ArrayBufferView implements List<int> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<int> get reversed =>

+ new ReversedListView<int>(this, 0, null);

void sort([int compare(int a, int b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -25237,9 +25392,11 @@ class Uint32Array extends ArrayBufferView implements List<int> {

throw new StateError("More than one element");

}

- int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);

+ int min([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);

+ int max([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.max(this, compare);

int removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -25360,11 +25517,13 @@ class Uint8Array extends ArrayBufferView implements List<int> {

void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<int> where(bool f(int element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);

@@ -25426,6 +25585,9 @@ class Uint8Array extends ArrayBufferView implements List<int> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<int> get reversed =>

+ new ReversedListView<int>(this, 0, null);

void sort([int compare(int a, int b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -25454,9 +25616,11 @@ class Uint8Array extends ArrayBufferView implements List<int> {

throw new StateError("More than one element");

}

- int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);

+ int min([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);

+ int max([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.max(this, compare);

int removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -25575,11 +25739,13 @@ class Uint8ClampedArray extends Uint8Array implements List<int> {

void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<int> where(bool f(int element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);

@@ -25641,6 +25807,9 @@ class Uint8ClampedArray extends Uint8Array implements List<int> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<int> get reversed =>

+ new ReversedListView<int>(this, 0, null);

void sort([int compare(int a, int b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -25669,9 +25838,11 @@ class Uint8ClampedArray extends Uint8Array implements List<int> {

throw new StateError("More than one element");

}

- int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);

+ int min([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);

+ int max([int compare(int a, int b)]) =>

+ IterableMixinWorkaround.max(this, compare);

int removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -29364,11 +29535,13 @@ class _ClientRectList extends NativeFieldWrapperClass1 implements List<ClientRec

void forEach(void f(ClientRect element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(ClientRect element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<ClientRect> where(bool f(ClientRect element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<ClientRect> where(bool f(ClientRect element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(ClientRect element)) => IterableMixinWorkaround.every(this, f);

@@ -29430,6 +29603,9 @@ class _ClientRectList extends NativeFieldWrapperClass1 implements List<ClientRec

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<ClientRect> get reversed =>

+ new ReversedListView<ClientRect>(this, 0, null);

void sort([int compare(ClientRect a, ClientRect b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -29458,9 +29634,11 @@ class _ClientRectList extends NativeFieldWrapperClass1 implements List<ClientRec

throw new StateError("More than one element");

}

- ClientRect min([int compare(ClientRect a, ClientRect b)]) => IterableMixinWorkaround.min(this, compare);

+ ClientRect min([int compare(ClientRect a, ClientRect b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- ClientRect max([int compare(ClientRect a, ClientRect b)]) => IterableMixinWorkaround.max(this, compare);

+ ClientRect max([int compare(ClientRect a, ClientRect b)]) =>

+ IterableMixinWorkaround.max(this, compare);

ClientRect removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -29553,11 +29731,13 @@ class _CssRuleList extends NativeFieldWrapperClass1 implements List<CssRule> {

void forEach(void f(CssRule element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(CssRule element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<CssRule> where(bool f(CssRule element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<CssRule> where(bool f(CssRule element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(CssRule element)) => IterableMixinWorkaround.every(this, f);

@@ -29619,6 +29799,9 @@ class _CssRuleList extends NativeFieldWrapperClass1 implements List<CssRule> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<CssRule> get reversed =>

+ new ReversedListView<CssRule>(this, 0, null);

void sort([int compare(CssRule a, CssRule b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -29647,9 +29830,11 @@ class _CssRuleList extends NativeFieldWrapperClass1 implements List<CssRule> {

throw new StateError("More than one element");

}

- CssRule min([int compare(CssRule a, CssRule b)]) => IterableMixinWorkaround.min(this, compare);

+ CssRule min([int compare(CssRule a, CssRule b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- CssRule max([int compare(CssRule a, CssRule b)]) => IterableMixinWorkaround.max(this, compare);

+ CssRule max([int compare(CssRule a, CssRule b)]) =>

+ IterableMixinWorkaround.max(this, compare);

CssRule removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -29742,11 +29927,13 @@ class _CssValueList extends CssValue implements List<CssValue> {

void forEach(void f(CssValue element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(CssValue element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<CssValue> where(bool f(CssValue element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<CssValue> where(bool f(CssValue element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(CssValue element)) => IterableMixinWorkaround.every(this, f);

@@ -29808,6 +29995,9 @@ class _CssValueList extends CssValue implements List<CssValue> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<CssValue> get reversed =>

+ new ReversedListView<CssValue>(this, 0, null);

void sort([int compare(CssValue a, CssValue b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -29836,9 +30026,11 @@ class _CssValueList extends CssValue implements List<CssValue> {

throw new StateError("More than one element");

}

- CssValue min([int compare(CssValue a, CssValue b)]) => IterableMixinWorkaround.min(this, compare);

+ CssValue min([int compare(CssValue a, CssValue b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- CssValue max([int compare(CssValue a, CssValue b)]) => IterableMixinWorkaround.max(this, compare);

+ CssValue max([int compare(CssValue a, CssValue b)]) =>

+ IterableMixinWorkaround.max(this, compare);

CssValue removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -30081,11 +30273,13 @@ class _EntryArray extends NativeFieldWrapperClass1 implements List<Entry> {

void forEach(void f(Entry element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(Entry element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<Entry> where(bool f(Entry element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<Entry> where(bool f(Entry element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(Entry element)) => IterableMixinWorkaround.every(this, f);

@@ -30147,6 +30341,9 @@ class _EntryArray extends NativeFieldWrapperClass1 implements List<Entry> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<Entry> get reversed =>

+ new ReversedListView<Entry>(this, 0, null);

void sort([int compare(Entry a, Entry b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -30175,9 +30372,11 @@ class _EntryArray extends NativeFieldWrapperClass1 implements List<Entry> {

throw new StateError("More than one element");

}

- Entry min([int compare(Entry a, Entry b)]) => IterableMixinWorkaround.min(this, compare);

+ Entry min([int compare(Entry a, Entry b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- Entry max([int compare(Entry a, Entry b)]) => IterableMixinWorkaround.max(this, compare);

+ Entry max([int compare(Entry a, Entry b)]) =>

+ IterableMixinWorkaround.max(this, compare);

Entry removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -30270,11 +30469,13 @@ class _EntryArraySync extends NativeFieldWrapperClass1 implements List<EntrySync

void forEach(void f(EntrySync element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(EntrySync element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<EntrySync> where(bool f(EntrySync element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<EntrySync> where(bool f(EntrySync element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(EntrySync element)) => IterableMixinWorkaround.every(this, f);

@@ -30336,6 +30537,9 @@ class _EntryArraySync extends NativeFieldWrapperClass1 implements List<EntrySync

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<EntrySync> get reversed =>

+ new ReversedListView<EntrySync>(this, 0, null);

void sort([int compare(EntrySync a, EntrySync b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -30364,9 +30568,11 @@ class _EntryArraySync extends NativeFieldWrapperClass1 implements List<EntrySync

throw new StateError("More than one element");

}

- EntrySync min([int compare(EntrySync a, EntrySync b)]) => IterableMixinWorkaround.min(this, compare);

+ EntrySync min([int compare(EntrySync a, EntrySync b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- EntrySync max([int compare(EntrySync a, EntrySync b)]) => IterableMixinWorkaround.max(this, compare);

+ EntrySync max([int compare(EntrySync a, EntrySync b)]) =>

+ IterableMixinWorkaround.max(this, compare);

EntrySync removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -30548,11 +30754,13 @@ class _GamepadList extends NativeFieldWrapperClass1 implements List<Gamepad> {

void forEach(void f(Gamepad element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(Gamepad element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<Gamepad> where(bool f(Gamepad element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<Gamepad> where(bool f(Gamepad element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(Gamepad element)) => IterableMixinWorkaround.every(this, f);

@@ -30614,6 +30822,9 @@ class _GamepadList extends NativeFieldWrapperClass1 implements List<Gamepad> {

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<Gamepad> get reversed =>

+ new ReversedListView<Gamepad>(this, 0, null);

void sort([int compare(Gamepad a, Gamepad b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -30642,9 +30853,11 @@ class _GamepadList extends NativeFieldWrapperClass1 implements List<Gamepad> {

throw new StateError("More than one element");

}

- Gamepad min([int compare(Gamepad a, Gamepad b)]) => IterableMixinWorkaround.min(this, compare);

+ Gamepad min([int compare(Gamepad a, Gamepad b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- Gamepad max([int compare(Gamepad a, Gamepad b)]) => IterableMixinWorkaround.max(this, compare);

+ Gamepad max([int compare(Gamepad a, Gamepad b)]) =>

+ IterableMixinWorkaround.max(this, compare);

Gamepad removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -30750,11 +30963,13 @@ class _MediaStreamList extends NativeFieldWrapperClass1 implements List<MediaStr

void forEach(void f(MediaStream element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(MediaStream element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<MediaStream> where(bool f(MediaStream element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<MediaStream> where(bool f(MediaStream element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(MediaStream element)) => IterableMixinWorkaround.every(this, f);

@@ -30816,6 +31031,9 @@ class _MediaStreamList extends NativeFieldWrapperClass1 implements List<MediaStr

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<MediaStream> get reversed =>

+ new ReversedListView<MediaStream>(this, 0, null);

void sort([int compare(MediaStream a, MediaStream b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -30844,9 +31062,11 @@ class _MediaStreamList extends NativeFieldWrapperClass1 implements List<MediaStr

throw new StateError("More than one element");

}

- MediaStream min([int compare(MediaStream a, MediaStream b)]) => IterableMixinWorkaround.min(this, compare);

+ MediaStream min([int compare(MediaStream a, MediaStream b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- MediaStream max([int compare(MediaStream a, MediaStream b)]) => IterableMixinWorkaround.max(this, compare);

+ MediaStream max([int compare(MediaStream a, MediaStream b)]) =>

+ IterableMixinWorkaround.max(this, compare);

MediaStream removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -30939,11 +31159,13 @@ class _SpeechInputResultList extends NativeFieldWrapperClass1 implements List<Sp

void forEach(void f(SpeechInputResult element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(SpeechInputResult element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<SpeechInputResult> where(bool f(SpeechInputResult element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<SpeechInputResult> where(bool f(SpeechInputResult element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(SpeechInputResult element)) => IterableMixinWorkaround.every(this, f);

@@ -31005,6 +31227,9 @@ class _SpeechInputResultList extends NativeFieldWrapperClass1 implements List<Sp

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<SpeechInputResult> get reversed =>

+ new ReversedListView<SpeechInputResult>(this, 0, null);

void sort([int compare(SpeechInputResult a, SpeechInputResult b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -31033,9 +31258,11 @@ class _SpeechInputResultList extends NativeFieldWrapperClass1 implements List<Sp

throw new StateError("More than one element");

}

- SpeechInputResult min([int compare(SpeechInputResult a, SpeechInputResult b)]) => IterableMixinWorkaround.min(this, compare);

+ SpeechInputResult min([int compare(SpeechInputResult a, SpeechInputResult b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- SpeechInputResult max([int compare(SpeechInputResult a, SpeechInputResult b)]) => IterableMixinWorkaround.max(this, compare);

+ SpeechInputResult max([int compare(SpeechInputResult a, SpeechInputResult b)]) =>

+ IterableMixinWorkaround.max(this, compare);

SpeechInputResult removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -31128,11 +31355,13 @@ class _SpeechRecognitionResultList extends NativeFieldWrapperClass1 implements L

void forEach(void f(SpeechRecognitionResult element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(SpeechRecognitionResult element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<SpeechRecognitionResult> where(bool f(SpeechRecognitionResult element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<SpeechRecognitionResult> where(bool f(SpeechRecognitionResult element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(SpeechRecognitionResult element)) => IterableMixinWorkaround.every(this, f);

@@ -31194,6 +31423,9 @@ class _SpeechRecognitionResultList extends NativeFieldWrapperClass1 implements L

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<SpeechRecognitionResult> get reversed =>

+ new ReversedListView<SpeechRecognitionResult>(this, 0, null);

void sort([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -31222,9 +31454,11 @@ class _SpeechRecognitionResultList extends NativeFieldWrapperClass1 implements L

throw new StateError("More than one element");

}

- SpeechRecognitionResult min([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) => IterableMixinWorkaround.min(this, compare);

+ SpeechRecognitionResult min([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- SpeechRecognitionResult max([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) => IterableMixinWorkaround.max(this, compare);

+ SpeechRecognitionResult max([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) =>

+ IterableMixinWorkaround.max(this, compare);

SpeechRecognitionResult removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

@@ -31317,11 +31551,13 @@ class _StyleSheetList extends NativeFieldWrapperClass1 implements List<StyleShee

void forEach(void f(StyleSheet element)) => IterableMixinWorkaround.forEach(this, f);

- String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);

+ String join([String separator]) =>

+ IterableMixinWorkaround.joinList(this, separator);

List mappedBy(f(StyleSheet element)) => IterableMixinWorkaround.mappedByList(this, f);

- Iterable<StyleSheet> where(bool f(StyleSheet element)) => IterableMixinWorkaround.where(this, f);

+ Iterable<StyleSheet> where(bool f(StyleSheet element)) =>

+ IterableMixinWorkaround.where(this, f);

bool every(bool f(StyleSheet element)) => IterableMixinWorkaround.every(this, f);

@@ -31383,6 +31619,9 @@ class _StyleSheetList extends NativeFieldWrapperClass1 implements List<StyleShee

throw new UnsupportedError("Cannot clear immutable List.");

}

+ List<StyleSheet> get reversed =>

+ new ReversedListView<StyleSheet>(this, 0, null);

void sort([int compare(StyleSheet a, StyleSheet b)]) {

throw new UnsupportedError("Cannot sort immutable List.");

}

@@ -31411,9 +31650,11 @@ class _StyleSheetList extends NativeFieldWrapperClass1 implements List<StyleShee

throw new StateError("More than one element");

}

- StyleSheet min([int compare(StyleSheet a, StyleSheet b)]) => IterableMixinWorkaround.min(this, compare);

+ StyleSheet min([int compare(StyleSheet a, StyleSheet b)]) =>

+ IterableMixinWorkaround.min(this, compare);

- StyleSheet max([int compare(StyleSheet a, StyleSheet b)]) => IterableMixinWorkaround.max(this, compare);

+ StyleSheet max([int compare(StyleSheet a, StyleSheet b)]) =>

+ IterableMixinWorkaround.max(this, compare);

StyleSheet removeAt(int pos) {

throw new UnsupportedError("Cannot remove from immutable List.");

« no previous file with comments | « sdk/lib/html/dart2js/html_dart2js.dart ('k') | sdk/lib/html/html_common/filtered_element_list.dart » ('j') | sdk/lib/svg/dart2js/svg_dart2js.dart » ('J')