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

Unified Diff: sdk/lib/html/dart2js/html_dart2js.dart

Side-by-side diff isn't available for this file because of its large size.

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/dart2js/html_dart2js.dart

diff --git a/sdk/lib/html/dart2js/html_dart2js.dart b/sdk/lib/html/dart2js/html_dart2js.dart

index 18829188a31a77a667b16623e190d713295a7872..0183c94d17f0e570614e5000a57d939cdcbfcb50 100644

--- a/sdk/lib/html/dart2js/html_dart2js.dart

+++ b/sdk/lib/html/dart2js/html_dart2js.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';

@@ -7173,11 +7174,13 @@ class DomMimeTypeArray implements JavaScriptIndexingBehavior, List<DomMimeType>

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);

@@ -7239,6 +7242,9 @@ class DomMimeTypeArray implements JavaScriptIndexingBehavior, List<DomMimeType>

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.");

}

@@ -7267,9 +7273,11 @@ class DomMimeTypeArray implements JavaScriptIndexingBehavior, List<DomMimeType>

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.");

@@ -7412,11 +7420,13 @@ class DomPluginArray implements JavaScriptIndexingBehavior, List<DomPlugin> nati

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);

@@ -7478,6 +7488,9 @@ class DomPluginArray implements JavaScriptIndexingBehavior, List<DomPlugin> nati

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.");

}

@@ -7506,9 +7519,11 @@ class DomPluginArray implements JavaScriptIndexingBehavior, List<DomPlugin> nati

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.");

@@ -7731,11 +7746,13 @@ class DomStringList implements JavaScriptIndexingBehavior, List<String> native "

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);

@@ -7797,6 +7814,9 @@ class DomStringList implements JavaScriptIndexingBehavior, List<String> native "

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.");

}

@@ -7825,9 +7845,11 @@ class DomStringList implements JavaScriptIndexingBehavior, List<String> native "

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.");

@@ -8057,6 +8079,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?');

}

@@ -8080,19 +8105,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) {

@@ -8279,6 +8304,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('');

}

@@ -10649,11 +10677,13 @@ class FileList implements JavaScriptIndexingBehavior, List<File> native "*FileLi

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);

@@ -10715,6 +10745,9 @@ class FileList implements JavaScriptIndexingBehavior, List<File> native "*FileLi

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.");

}

@@ -10743,9 +10776,11 @@ class FileList implements JavaScriptIndexingBehavior, List<File> native "*FileLi

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.");

@@ -11238,11 +11273,13 @@ class Float32Array extends ArrayBufferView implements JavaScriptIndexingBehavior

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);

@@ -11304,6 +11341,9 @@ class Float32Array extends ArrayBufferView implements JavaScriptIndexingBehavior

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.");

}

@@ -11332,9 +11372,11 @@ class Float32Array extends ArrayBufferView implements JavaScriptIndexingBehavior

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.");

@@ -11436,11 +11478,13 @@ class Float64Array extends ArrayBufferView implements JavaScriptIndexingBehavior

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);

@@ -11502,6 +11546,9 @@ class Float64Array extends ArrayBufferView implements JavaScriptIndexingBehavior

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.");

}

@@ -11530,9 +11577,11 @@ class Float64Array extends ArrayBufferView implements JavaScriptIndexingBehavior

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.");

@@ -11933,11 +11982,13 @@ class HtmlAllCollection implements JavaScriptIndexingBehavior, List<Node> native

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);

@@ -11999,6 +12050,9 @@ class HtmlAllCollection implements JavaScriptIndexingBehavior, List<Node> native

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.");

}

@@ -12027,9 +12081,11 @@ class HtmlAllCollection implements JavaScriptIndexingBehavior, List<Node> native

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.");

@@ -12128,11 +12184,13 @@ class HtmlCollection implements JavaScriptIndexingBehavior, List<Node> native "*

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);

@@ -12194,6 +12252,9 @@ class HtmlCollection implements JavaScriptIndexingBehavior, List<Node> native "*

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.");

}

@@ -12222,9 +12283,11 @@ class HtmlCollection implements JavaScriptIndexingBehavior, List<Node> native "*

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.");

@@ -13905,11 +13968,13 @@ class Int16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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);

@@ -13971,6 +14036,9 @@ class Int16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

}

@@ -13999,9 +14067,11 @@ class Int16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

@@ -14103,11 +14173,13 @@ class Int32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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);

@@ -14169,6 +14241,9 @@ class Int32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

}

@@ -14197,9 +14272,11 @@ class Int32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

@@ -14301,11 +14378,13 @@ class Int8Array extends ArrayBufferView implements JavaScriptIndexingBehavior, L

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);

@@ -14367,6 +14446,9 @@ class Int8Array extends ArrayBufferView implements JavaScriptIndexingBehavior, L

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.");

}

@@ -14395,9 +14477,11 @@ class Int8Array extends ArrayBufferView implements JavaScriptIndexingBehavior, L

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.");

@@ -16550,11 +16634,13 @@ class NamedNodeMap implements JavaScriptIndexingBehavior, List<Node> native "*Na

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);

@@ -16616,6 +16702,9 @@ class NamedNodeMap implements JavaScriptIndexingBehavior, List<Node> native "*Na

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.");

}

@@ -16644,9 +16733,11 @@ class NamedNodeMap implements JavaScriptIndexingBehavior, List<Node> native "*Na

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.");

@@ -17062,6 +17153,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)]) {

@@ -17393,11 +17487,13 @@ class NodeList implements JavaScriptIndexingBehavior, List<Node> native "*NodeLi

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);

@@ -17459,6 +17555,9 @@ class NodeList implements JavaScriptIndexingBehavior, List<Node> native "*NodeLi

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.");

}

@@ -17487,9 +17586,11 @@ class NodeList implements JavaScriptIndexingBehavior, List<Node> native "*NodeLi

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.");

@@ -19785,11 +19886,13 @@ class SourceBufferList extends EventTarget implements JavaScriptIndexingBehavior

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);

@@ -19851,6 +19954,9 @@ class SourceBufferList extends EventTarget implements JavaScriptIndexingBehavior

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.");

}

@@ -19879,9 +19985,11 @@ class SourceBufferList extends EventTarget implements JavaScriptIndexingBehavior

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.");

@@ -20046,11 +20154,13 @@ class SpeechGrammarList implements JavaScriptIndexingBehavior, List<SpeechGramma

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);

@@ -20112,6 +20222,9 @@ class SpeechGrammarList implements JavaScriptIndexingBehavior, List<SpeechGramma

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.");

}

@@ -20140,9 +20253,11 @@ class SpeechGrammarList implements JavaScriptIndexingBehavior, List<SpeechGramma

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.");

@@ -20650,11 +20765,13 @@ class SqlResultSetRowList implements JavaScriptIndexingBehavior, List<Map> nativ

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);

@@ -20716,6 +20833,9 @@ class SqlResultSetRowList implements JavaScriptIndexingBehavior, List<Map> nativ

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.");

}

@@ -20744,9 +20864,11 @@ class SqlResultSetRowList implements JavaScriptIndexingBehavior, List<Map> nativ

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.");

@@ -21710,11 +21832,13 @@ class TextTrackCueList implements List<TextTrackCue>, JavaScriptIndexingBehavior

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);

@@ -21776,6 +21900,9 @@ class TextTrackCueList implements List<TextTrackCue>, JavaScriptIndexingBehavior

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.");

}

@@ -21804,9 +21931,11 @@ class TextTrackCueList implements List<TextTrackCue>, JavaScriptIndexingBehavior

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.");

@@ -21908,11 +22037,13 @@ class TextTrackList extends EventTarget implements JavaScriptIndexingBehavior, L

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);

@@ -21974,6 +22105,9 @@ class TextTrackList extends EventTarget implements JavaScriptIndexingBehavior, L

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.");

}

@@ -22002,9 +22136,11 @@ class TextTrackList extends EventTarget implements JavaScriptIndexingBehavior, L

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.");

@@ -22280,11 +22416,13 @@ class TouchList implements JavaScriptIndexingBehavior, List<Touch> native "*Touc

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);

@@ -22346,6 +22484,9 @@ class TouchList implements JavaScriptIndexingBehavior, List<Touch> native "*Touc

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.");

}

@@ -22374,9 +22515,11 @@ class TouchList implements JavaScriptIndexingBehavior, List<Touch> native "*Touc

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.");

@@ -22701,11 +22844,13 @@ class Uint16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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);

@@ -22767,6 +22912,9 @@ class Uint16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

}

@@ -22795,9 +22943,11 @@ class Uint16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

@@ -22899,11 +23049,13 @@ class Uint32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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);

@@ -22965,6 +23117,9 @@ class Uint32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

}

@@ -22993,9 +23148,11 @@ class Uint32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

@@ -23097,11 +23254,13 @@ class Uint8Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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);

@@ -23163,6 +23322,9 @@ class Uint8Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

}

@@ -23191,9 +23353,11 @@ class Uint8Array extends ArrayBufferView implements JavaScriptIndexingBehavior,

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.");

@@ -23292,11 +23456,13 @@ class Uint8ClampedArray extends Uint8Array implements JavaScriptIndexingBehavior

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);

@@ -23358,6 +23524,9 @@ class Uint8ClampedArray extends Uint8Array implements JavaScriptIndexingBehavior

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.");

}

@@ -23386,9 +23555,11 @@ class Uint8ClampedArray extends Uint8Array implements JavaScriptIndexingBehavior

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.");

@@ -27108,11 +27279,13 @@ class _ClientRectList implements JavaScriptIndexingBehavior, List<ClientRect> na

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);

@@ -27174,6 +27347,9 @@ class _ClientRectList implements JavaScriptIndexingBehavior, List<ClientRect> na

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.");

}

@@ -27202,9 +27378,11 @@ class _ClientRectList implements JavaScriptIndexingBehavior, List<ClientRect> na

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.");

@@ -27293,11 +27471,13 @@ class _CssRuleList implements JavaScriptIndexingBehavior, List<CssRule> native "

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);

@@ -27359,6 +27539,9 @@ class _CssRuleList implements JavaScriptIndexingBehavior, List<CssRule> native "

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.");

}

@@ -27387,9 +27570,11 @@ class _CssRuleList implements JavaScriptIndexingBehavior, List<CssRule> native "

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.");

@@ -27478,11 +27663,13 @@ class _CssValueList extends CssValue implements List<CssValue>, JavaScriptIndexi

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);

@@ -27544,6 +27731,9 @@ class _CssValueList extends CssValue implements List<CssValue>, JavaScriptIndexi

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.");

}

@@ -27572,9 +27762,11 @@ class _CssValueList extends CssValue implements List<CssValue>, JavaScriptIndexi

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.");

@@ -27672,11 +27864,13 @@ class _EntryArray implements JavaScriptIndexingBehavior, List<Entry> native "*En

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);

@@ -27738,6 +27932,9 @@ class _EntryArray implements JavaScriptIndexingBehavior, List<Entry> native "*En

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.");

}

@@ -27766,9 +27963,11 @@ class _EntryArray implements JavaScriptIndexingBehavior, List<Entry> native "*En

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.");

@@ -27857,11 +28056,13 @@ class _EntryArraySync implements JavaScriptIndexingBehavior, List<EntrySync> nat

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);

@@ -27923,6 +28124,9 @@ class _EntryArraySync implements JavaScriptIndexingBehavior, List<EntrySync> nat

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.");

}

@@ -27951,9 +28155,11 @@ class _EntryArraySync implements JavaScriptIndexingBehavior, List<EntrySync> nat

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.");

@@ -28119,11 +28325,13 @@ class _GamepadList implements JavaScriptIndexingBehavior, List<Gamepad> native "

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);

@@ -28185,6 +28393,9 @@ class _GamepadList implements JavaScriptIndexingBehavior, List<Gamepad> native "

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.");

}

@@ -28213,9 +28424,11 @@ class _GamepadList implements JavaScriptIndexingBehavior, List<Gamepad> native "

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.");

@@ -28313,11 +28526,13 @@ class _MediaStreamList implements JavaScriptIndexingBehavior, List<MediaStream>

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);

@@ -28379,6 +28594,9 @@ class _MediaStreamList implements JavaScriptIndexingBehavior, List<MediaStream>

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.");

}

@@ -28407,9 +28625,11 @@ class _MediaStreamList implements JavaScriptIndexingBehavior, List<MediaStream>

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.");

@@ -28498,11 +28718,13 @@ class _SpeechInputResultList implements JavaScriptIndexingBehavior, List<SpeechI

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);

@@ -28564,6 +28786,9 @@ class _SpeechInputResultList implements JavaScriptIndexingBehavior, List<SpeechI

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.");

}

@@ -28592,9 +28817,11 @@ class _SpeechInputResultList implements JavaScriptIndexingBehavior, List<SpeechI

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.");

@@ -28683,11 +28910,13 @@ class _SpeechRecognitionResultList implements JavaScriptIndexingBehavior, List<S

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);

@@ -28749,6 +28978,9 @@ class _SpeechRecognitionResultList implements JavaScriptIndexingBehavior, List<S

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.");

}

@@ -28777,9 +29009,11 @@ class _SpeechRecognitionResultList implements JavaScriptIndexingBehavior, List<S

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.");

@@ -28868,11 +29102,13 @@ class _StyleSheetList implements JavaScriptIndexingBehavior, List<StyleSheet> na

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);

@@ -28934,6 +29170,9 @@ class _StyleSheetList implements JavaScriptIndexingBehavior, List<StyleSheet> na

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.");

}

@@ -28962,9 +29201,11 @@ class _StyleSheetList implements JavaScriptIndexingBehavior, List<StyleSheet> na

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 | « no previous file | sdk/lib/html/dartium/html_dartium.dart » ('j') | sdk/lib/svg/dart2js/svg_dart2js.dart » ('J')