Rename XMatching to XWhere.

sdk/lib/svg/dart2js/svg_dart2js.dart

 library dart.dom.svg;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'dart:html_common';
 import 'dart:_js_helper' show Creates, Returns, JavaScriptIndexingBehavior, JSName;
 import 'dart:_foreign_helper' show JS;
 // DO NOT EDIT - unless you are editing documentation as per:
 // https://code.google.com/p/dart/wiki/ContributingHTMLDocumentation
@@ skipping 3094 matching lines @@
   Iterable<Length> takeWhile(bool test(Length value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
   Iterable<Length> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<Length> skipWhile(bool test(Length value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
-  Length firstMatching(bool test(Length value), { Length orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+  Length firstWhere(bool test(Length value), { Length orElse() }) {
+    return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
-  Length lastMatching(bool test(Length value), {Length orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+  Length lastWhere(bool test(Length value), {Length orElse()}) {
+    return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
 
-  Length singleMatching(bool test(Length value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+  Length singleWhere(bool test(Length value)) {
+    return IterableMixinWorkaround.singleWhere(this, test);
   }
 
   Length elementAt(int index) {
     return this[index];
   }
 
   // From Collection<Length>:
 
   void add(Length value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 65 matching lines @@
   }
 
   void removeAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void retainAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void removeMatching(bool test(Length element)) {
+  void removeWhere(bool test(Length element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void retainMatching(bool test(Length element)) {
+  void retainWhere(bool test(Length element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Length> from, [int startFrom]) {
     throw new UnsupportedError("Cannot setRange on immutable List.");
   }
 
   void removeRange(int start, int rangeLength) {
     throw new UnsupportedError("Cannot removeRange on immutable List.");
   }
@@ skipping 509 matching lines @@
   Iterable<Number> takeWhile(bool test(Number value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
   Iterable<Number> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<Number> skipWhile(bool test(Number value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
-  Number firstMatching(bool test(Number value), { Number orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+  Number firstWhere(bool test(Number value), { Number orElse() }) {
+    return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
-  Number lastMatching(bool test(Number value), {Number orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+  Number lastWhere(bool test(Number value), {Number orElse()}) {
+    return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
 
-  Number singleMatching(bool test(Number value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+  Number singleWhere(bool test(Number value)) {
+    return IterableMixinWorkaround.singleWhere(this, test);
   }
 
   Number elementAt(int index) {
     return this[index];
   }
 
   // From Collection<Number>:
 
   void add(Number value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 65 matching lines @@
   }
 
   void removeAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void retainAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void removeMatching(bool test(Number element)) {
+  void removeWhere(bool test(Number element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void retainMatching(bool test(Number element)) {
+  void retainWhere(bool test(Number element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Number> from, [int startFrom]) {
     throw new UnsupportedError("Cannot setRange on immutable List.");
   }
 
   void removeRange(int start, int rangeLength) {
     throw new UnsupportedError("Cannot removeRange on immutable List.");
   }
@@ skipping 785 matching lines @@
   Iterable<PathSeg> takeWhile(bool test(PathSeg value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
   Iterable<PathSeg> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<PathSeg> skipWhile(bool test(PathSeg value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
-  PathSeg firstMatching(bool test(PathSeg value), { PathSeg orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+  PathSeg firstWhere(bool test(PathSeg value), { PathSeg orElse() }) {
+    return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
-  PathSeg lastMatching(bool test(PathSeg value), {PathSeg orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+  PathSeg lastWhere(bool test(PathSeg value), {PathSeg orElse()}) {
+    return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
 
-  PathSeg singleMatching(bool test(PathSeg value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+  PathSeg singleWhere(bool test(PathSeg value)) {
+    return IterableMixinWorkaround.singleWhere(this, test);
   }
 
   PathSeg elementAt(int index) {
     return this[index];
   }
 
   // From Collection<PathSeg>:
 
   void add(PathSeg value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 65 matching lines @@
   }
 
   void removeAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void retainAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void removeMatching(bool test(PathSeg element)) {
+  void removeWhere(bool test(PathSeg element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void retainMatching(bool test(PathSeg element)) {
+  void retainWhere(bool test(PathSeg element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<PathSeg> from, [int startFrom]) {
     throw new UnsupportedError("Cannot setRange on immutable List.");
   }
 
   void removeRange(int start, int rangeLength) {
     throw new UnsupportedError("Cannot removeRange on immutable List.");
   }
@@ skipping 770 matching lines @@
   Iterable<String> takeWhile(bool test(String value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
   Iterable<String> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<String> skipWhile(bool test(String value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
-  String firstMatching(bool test(String value), { String orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+  String firstWhere(bool test(String value), { String orElse() }) {
+    return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
-  String lastMatching(bool test(String value), {String orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+  String lastWhere(bool test(String value), {String orElse()}) {
+    return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
 
-  String singleMatching(bool test(String value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+  String singleWhere(bool test(String value)) {
+    return IterableMixinWorkaround.singleWhere(this, test);
   }
 
   String elementAt(int index) {
     return this[index];
   }
 
   // From Collection<String>:
 
   void add(String value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 65 matching lines @@
   }
 
   void removeAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void retainAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void removeMatching(bool test(String element)) {
+  void removeWhere(bool test(String element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void retainMatching(bool test(String element)) {
+  void retainWhere(bool test(String element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<String> from, [int startFrom]) {
     throw new UnsupportedError("Cannot setRange on immutable List.");
   }
 
   void removeRange(int start, int rangeLength) {
     throw new UnsupportedError("Cannot removeRange on immutable List.");
   }
@@ skipping 1047 matching lines @@
   Iterable<Transform> takeWhile(bool test(Transform value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
   Iterable<Transform> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<Transform> skipWhile(bool test(Transform value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
-  Transform firstMatching(bool test(Transform value), { Transform orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+  Transform firstWhere(bool test(Transform value), { Transform orElse() }) {
+    return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
-  Transform lastMatching(bool test(Transform value), {Transform orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+  Transform lastWhere(bool test(Transform value), {Transform orElse()}) {
+    return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
 
-  Transform singleMatching(bool test(Transform value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+  Transform singleWhere(bool test(Transform value)) {
+    return IterableMixinWorkaround.singleWhere(this, test);
   }
 
   Transform elementAt(int index) {
     return this[index];
   }
 
   // From Collection<Transform>:
 
   void add(Transform value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 65 matching lines @@
   }
 
   void removeAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void retainAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void removeMatching(bool test(Transform element)) {
+  void removeWhere(bool test(Transform element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void retainMatching(bool test(Transform element)) {
+  void retainWhere(bool test(Transform element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Transform> from, [int startFrom]) {
     throw new UnsupportedError("Cannot setRange on immutable List.");
   }
 
   void removeRange(int start, int rangeLength) {
     throw new UnsupportedError("Cannot removeRange on immutable List.");
   }
@@ skipping 402 matching lines @@
   Iterable<ElementInstance> takeWhile(bool test(ElementInstance value)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
   Iterable<ElementInstance> skip(int n) => IterableMixinWorkaround.skipList(this, n);
 
   Iterable<ElementInstance> skipWhile(bool test(ElementInstance value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
-  ElementInstance firstMatching(bool test(ElementInstance value), { ElementInstance orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+  ElementInstance firstWhere(bool test(ElementInstance value), { ElementInstance orElse() }) {
+    return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
-  ElementInstance lastMatching(bool test(ElementInstance value), {ElementInstance orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+  ElementInstance lastWhere(bool test(ElementInstance value), {ElementInstance orElse()}) {
+    return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
 
-  ElementInstance singleMatching(bool test(ElementInstance value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+  ElementInstance singleWhere(bool test(ElementInstance value)) {
+    return IterableMixinWorkaround.singleWhere(this, test);
   }
 
   ElementInstance elementAt(int index) {
     return this[index];
   }
 
   // From Collection<ElementInstance>:
 
   void add(ElementInstance value) {
     throw new UnsupportedError("Cannot add to immutable List.");
@@ skipping 67 matching lines @@
   }
 
   void removeAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void retainAll(Iterable elements) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void removeMatching(bool test(ElementInstance element)) {
+  void removeWhere(bool test(ElementInstance element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
-  void retainMatching(bool test(ElementInstance element)) {
+  void retainWhere(bool test(ElementInstance element)) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<ElementInstance> from, [int startFrom]) {
     throw new UnsupportedError("Cannot setRange on immutable List.");
   }
 
   void removeRange(int start, int rangeLength) {
     throw new UnsupportedError("Cannot removeRange on immutable List.");
   }
@@ skipping 419 matching lines @@
 
 
 @DocsEditable
 @DomName('SVGVKernElement')
 class _SVGVKernElement extends SvgElement native "*SVGVKernElement" {
 
   @DomName('SVGVKernElement.SVGVKernElement')
   @DocsEditable
   factory _SVGVKernElement() => _SvgElementFactoryProvider.createSvgElement_tag("vkern");
 }