Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(503)

Side by Side Diff: sdk/lib/svg/dartium/svg_dartium.dart

Issue 12090093: Reapply "Rename mappedBy to map." (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Fixed bug in previous commit. Created 7 years, 10 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:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « sdk/lib/svg/dart2js/svg_dart2js.dart ('k') | tests/compiler/dart2js/type_checker_test.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 library svg; 1 library svg;
2 2
3 import 'dart:async'; 3 import 'dart:async';
4 import 'dart:collection'; 4 import 'dart:collection';
5 import 'dart:html'; 5 import 'dart:html';
6 import 'dart:html_common'; 6 import 'dart:html_common';
7 import 'dart:nativewrappers'; 7 import 'dart:nativewrappers';
8 // DO NOT EDIT 8 // DO NOT EDIT
9 // Auto-generated dart:svg library. 9 // Auto-generated dart:svg library.
10 10
(...skipping 3945 matching lines...) Expand 10 before | Expand all | Expand 10 after
3956 return IterableMixinWorkaround.reduce(this, initialValue, combine); 3956 return IterableMixinWorkaround.reduce(this, initialValue, combine);
3957 } 3957 }
3958 3958
3959 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t); 3959 bool contains(Length element) => IterableMixinWorkaround.contains(this, elemen t);
3960 3960
3961 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f); 3961 void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f);
3962 3962
3963 String join([String separator]) => 3963 String join([String separator]) =>
3964 IterableMixinWorkaround.joinList(this, separator); 3964 IterableMixinWorkaround.joinList(this, separator);
3965 3965
3966 List mappedBy(f(Length element)) => IterableMixinWorkaround.mappedByList(this, f); 3966 Iterable map(f(Length element)) =>
3967 IterableMixinWorkaround.map(this, f);
3968
3969 List mappedBy(f(Length element)) =>
3970 IterableMixinWorkaround.mappedByList(this, f);
3967 3971
3968 Iterable<Length> where(bool f(Length element)) => 3972 Iterable<Length> where(bool f(Length element)) =>
3969 IterableMixinWorkaround.where(this, f); 3973 IterableMixinWorkaround.where(this, f);
3970 3974
3971 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f); 3975 bool every(bool f(Length element)) => IterableMixinWorkaround.every(this, f);
3972 3976
3973 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f); 3977 bool any(bool f(Length element)) => IterableMixinWorkaround.any(this, f);
3974 3978
3975 List<Length> toList() => new List<Length>.from(this); 3979 List<Length> toList() => new List<Length>.from(this);
3976 Set<Length> toSet() => new Set<Length>.from(this); 3980 Set<Length> toSet() => new Set<Length>.from(this);
3977 3981
3978 bool get isEmpty => this.length == 0; 3982 bool get isEmpty => this.length == 0;
3979 3983
3980 List<Length> take(int n) => IterableMixinWorkaround.takeList(this, n); 3984 Iterable<Length> take(int n) => IterableMixinWorkaround.takeList(this, n);
3981 3985
3982 Iterable<Length> takeWhile(bool test(Length value)) { 3986 Iterable<Length> takeWhile(bool test(Length value)) {
3983 return IterableMixinWorkaround.takeWhile(this, test); 3987 return IterableMixinWorkaround.takeWhile(this, test);
3984 } 3988 }
3985 3989
3986 List<Length> skip(int n) => IterableMixinWorkaround.skipList(this, n); 3990 Iterable<Length> skip(int n) => IterableMixinWorkaround.skipList(this, n);
3987 3991
3988 Iterable<Length> skipWhile(bool test(Length value)) { 3992 Iterable<Length> skipWhile(bool test(Length value)) {
3989 return IterableMixinWorkaround.skipWhile(this, test); 3993 return IterableMixinWorkaround.skipWhile(this, test);
3990 } 3994 }
3991 3995
3992 Length firstMatching(bool test(Length value), { Length orElse() }) { 3996 Length firstMatching(bool test(Length value), { Length orElse() }) {
3993 return IterableMixinWorkaround.firstMatching(this, test, orElse); 3997 return IterableMixinWorkaround.firstMatching(this, test, orElse);
3994 } 3998 }
3995 3999
3996 Length lastMatching(bool test(Length value), {Length orElse()}) { 4000 Length lastMatching(bool test(Length value), {Length orElse()}) {
(...skipping 725 matching lines...) Expand 10 before | Expand all | Expand 10 after
4722 return IterableMixinWorkaround.reduce(this, initialValue, combine); 4726 return IterableMixinWorkaround.reduce(this, initialValue, combine);
4723 } 4727 }
4724 4728
4725 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t); 4729 bool contains(Number element) => IterableMixinWorkaround.contains(this, elemen t);
4726 4730
4727 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f); 4731 void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f);
4728 4732
4729 String join([String separator]) => 4733 String join([String separator]) =>
4730 IterableMixinWorkaround.joinList(this, separator); 4734 IterableMixinWorkaround.joinList(this, separator);
4731 4735
4732 List mappedBy(f(Number element)) => IterableMixinWorkaround.mappedByList(this, f); 4736 Iterable map(f(Number element)) =>
4737 IterableMixinWorkaround.map(this, f);
4738
4739 List mappedBy(f(Number element)) =>
4740 IterableMixinWorkaround.mappedByList(this, f);
4733 4741
4734 Iterable<Number> where(bool f(Number element)) => 4742 Iterable<Number> where(bool f(Number element)) =>
4735 IterableMixinWorkaround.where(this, f); 4743 IterableMixinWorkaround.where(this, f);
4736 4744
4737 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f); 4745 bool every(bool f(Number element)) => IterableMixinWorkaround.every(this, f);
4738 4746
4739 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f); 4747 bool any(bool f(Number element)) => IterableMixinWorkaround.any(this, f);
4740 4748
4741 List<Number> toList() => new List<Number>.from(this); 4749 List<Number> toList() => new List<Number>.from(this);
4742 Set<Number> toSet() => new Set<Number>.from(this); 4750 Set<Number> toSet() => new Set<Number>.from(this);
4743 4751
4744 bool get isEmpty => this.length == 0; 4752 bool get isEmpty => this.length == 0;
4745 4753
4746 List<Number> take(int n) => IterableMixinWorkaround.takeList(this, n); 4754 Iterable<Number> take(int n) => IterableMixinWorkaround.takeList(this, n);
4747 4755
4748 Iterable<Number> takeWhile(bool test(Number value)) { 4756 Iterable<Number> takeWhile(bool test(Number value)) {
4749 return IterableMixinWorkaround.takeWhile(this, test); 4757 return IterableMixinWorkaround.takeWhile(this, test);
4750 } 4758 }
4751 4759
4752 List<Number> skip(int n) => IterableMixinWorkaround.skipList(this, n); 4760 Iterable<Number> skip(int n) => IterableMixinWorkaround.skipList(this, n);
4753 4761
4754 Iterable<Number> skipWhile(bool test(Number value)) { 4762 Iterable<Number> skipWhile(bool test(Number value)) {
4755 return IterableMixinWorkaround.skipWhile(this, test); 4763 return IterableMixinWorkaround.skipWhile(this, test);
4756 } 4764 }
4757 4765
4758 Number firstMatching(bool test(Number value), { Number orElse() }) { 4766 Number firstMatching(bool test(Number value), { Number orElse() }) {
4759 return IterableMixinWorkaround.firstMatching(this, test, orElse); 4767 return IterableMixinWorkaround.firstMatching(this, test, orElse);
4760 } 4768 }
4761 4769
4762 Number lastMatching(bool test(Number value), {Number orElse()}) { 4770 Number lastMatching(bool test(Number value), {Number orElse()}) {
(...skipping 1143 matching lines...) Expand 10 before | Expand all | Expand 10 after
5906 return IterableMixinWorkaround.reduce(this, initialValue, combine); 5914 return IterableMixinWorkaround.reduce(this, initialValue, combine);
5907 } 5915 }
5908 5916
5909 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt); 5917 bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, eleme nt);
5910 5918
5911 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f); 5919 void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f);
5912 5920
5913 String join([String separator]) => 5921 String join([String separator]) =>
5914 IterableMixinWorkaround.joinList(this, separator); 5922 IterableMixinWorkaround.joinList(this, separator);
5915 5923
5916 List mappedBy(f(PathSeg element)) => IterableMixinWorkaround.mappedByList(this , f); 5924 Iterable map(f(PathSeg element)) =>
5925 IterableMixinWorkaround.map(this, f);
5926
5927 List mappedBy(f(PathSeg element)) =>
5928 IterableMixinWorkaround.mappedByList(this, f);
5917 5929
5918 Iterable<PathSeg> where(bool f(PathSeg element)) => 5930 Iterable<PathSeg> where(bool f(PathSeg element)) =>
5919 IterableMixinWorkaround.where(this, f); 5931 IterableMixinWorkaround.where(this, f);
5920 5932
5921 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f); 5933 bool every(bool f(PathSeg element)) => IterableMixinWorkaround.every(this, f);
5922 5934
5923 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f); 5935 bool any(bool f(PathSeg element)) => IterableMixinWorkaround.any(this, f);
5924 5936
5925 List<PathSeg> toList() => new List<PathSeg>.from(this); 5937 List<PathSeg> toList() => new List<PathSeg>.from(this);
5926 Set<PathSeg> toSet() => new Set<PathSeg>.from(this); 5938 Set<PathSeg> toSet() => new Set<PathSeg>.from(this);
5927 5939
5928 bool get isEmpty => this.length == 0; 5940 bool get isEmpty => this.length == 0;
5929 5941
5930 List<PathSeg> take(int n) => IterableMixinWorkaround.takeList(this, n); 5942 Iterable<PathSeg> take(int n) => IterableMixinWorkaround.takeList(this, n);
5931 5943
5932 Iterable<PathSeg> takeWhile(bool test(PathSeg value)) { 5944 Iterable<PathSeg> takeWhile(bool test(PathSeg value)) {
5933 return IterableMixinWorkaround.takeWhile(this, test); 5945 return IterableMixinWorkaround.takeWhile(this, test);
5934 } 5946 }
5935 5947
5936 List<PathSeg> skip(int n) => IterableMixinWorkaround.skipList(this, n); 5948 Iterable<PathSeg> skip(int n) => IterableMixinWorkaround.skipList(this, n);
5937 5949
5938 Iterable<PathSeg> skipWhile(bool test(PathSeg value)) { 5950 Iterable<PathSeg> skipWhile(bool test(PathSeg value)) {
5939 return IterableMixinWorkaround.skipWhile(this, test); 5951 return IterableMixinWorkaround.skipWhile(this, test);
5940 } 5952 }
5941 5953
5942 PathSeg firstMatching(bool test(PathSeg value), { PathSeg orElse() }) { 5954 PathSeg firstMatching(bool test(PathSeg value), { PathSeg orElse() }) {
5943 return IterableMixinWorkaround.firstMatching(this, test, orElse); 5955 return IterableMixinWorkaround.firstMatching(this, test, orElse);
5944 } 5956 }
5945 5957
5946 PathSeg lastMatching(bool test(PathSeg value), {PathSeg orElse()}) { 5958 PathSeg lastMatching(bool test(PathSeg value), {PathSeg orElse()}) {
(...skipping 983 matching lines...) Expand 10 before | Expand all | Expand 10 after
6930 return IterableMixinWorkaround.reduce(this, initialValue, combine); 6942 return IterableMixinWorkaround.reduce(this, initialValue, combine);
6931 } 6943 }
6932 6944
6933 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t); 6945 bool contains(String element) => IterableMixinWorkaround.contains(this, elemen t);
6934 6946
6935 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f); 6947 void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
6936 6948
6937 String join([String separator]) => 6949 String join([String separator]) =>
6938 IterableMixinWorkaround.joinList(this, separator); 6950 IterableMixinWorkaround.joinList(this, separator);
6939 6951
6940 List mappedBy(f(String element)) => IterableMixinWorkaround.mappedByList(this, f); 6952 Iterable map(f(String element)) =>
6953 IterableMixinWorkaround.map(this, f);
6954
6955 List mappedBy(f(String element)) =>
6956 IterableMixinWorkaround.mappedByList(this, f);
6941 6957
6942 Iterable<String> where(bool f(String element)) => 6958 Iterable<String> where(bool f(String element)) =>
6943 IterableMixinWorkaround.where(this, f); 6959 IterableMixinWorkaround.where(this, f);
6944 6960
6945 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f); 6961 bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f);
6946 6962
6947 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f); 6963 bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f);
6948 6964
6949 List<String> toList() => new List<String>.from(this); 6965 List<String> toList() => new List<String>.from(this);
6950 Set<String> toSet() => new Set<String>.from(this); 6966 Set<String> toSet() => new Set<String>.from(this);
6951 6967
6952 bool get isEmpty => this.length == 0; 6968 bool get isEmpty => this.length == 0;
6953 6969
6954 List<String> take(int n) => IterableMixinWorkaround.takeList(this, n); 6970 Iterable<String> take(int n) => IterableMixinWorkaround.takeList(this, n);
6955 6971
6956 Iterable<String> takeWhile(bool test(String value)) { 6972 Iterable<String> takeWhile(bool test(String value)) {
6957 return IterableMixinWorkaround.takeWhile(this, test); 6973 return IterableMixinWorkaround.takeWhile(this, test);
6958 } 6974 }
6959 6975
6960 List<String> skip(int n) => IterableMixinWorkaround.skipList(this, n); 6976 Iterable<String> skip(int n) => IterableMixinWorkaround.skipList(this, n);
6961 6977
6962 Iterable<String> skipWhile(bool test(String value)) { 6978 Iterable<String> skipWhile(bool test(String value)) {
6963 return IterableMixinWorkaround.skipWhile(this, test); 6979 return IterableMixinWorkaround.skipWhile(this, test);
6964 } 6980 }
6965 6981
6966 String firstMatching(bool test(String value), { String orElse() }) { 6982 String firstMatching(bool test(String value), { String orElse() }) {
6967 return IterableMixinWorkaround.firstMatching(this, test, orElse); 6983 return IterableMixinWorkaround.firstMatching(this, test, orElse);
6968 } 6984 }
6969 6985
6970 String lastMatching(bool test(String value), {String orElse()}) { 6986 String lastMatching(bool test(String value), {String orElse()}) {
(...skipping 1278 matching lines...) Expand 10 before | Expand all | Expand 10 after
8249 return IterableMixinWorkaround.reduce(this, initialValue, combine); 8265 return IterableMixinWorkaround.reduce(this, initialValue, combine);
8250 } 8266 }
8251 8267
8252 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment); 8268 bool contains(Transform element) => IterableMixinWorkaround.contains(this, ele ment);
8253 8269
8254 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f); 8270 void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(thi s, f);
8255 8271
8256 String join([String separator]) => 8272 String join([String separator]) =>
8257 IterableMixinWorkaround.joinList(this, separator); 8273 IterableMixinWorkaround.joinList(this, separator);
8258 8274
8259 List mappedBy(f(Transform element)) => IterableMixinWorkaround.mappedByList(th is, f); 8275 Iterable map(f(Transform element)) =>
8276 IterableMixinWorkaround.map(this, f);
8277
8278 List mappedBy(f(Transform element)) =>
8279 IterableMixinWorkaround.mappedByList(this, f);
8260 8280
8261 Iterable<Transform> where(bool f(Transform element)) => 8281 Iterable<Transform> where(bool f(Transform element)) =>
8262 IterableMixinWorkaround.where(this, f); 8282 IterableMixinWorkaround.where(this, f);
8263 8283
8264 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f ); 8284 bool every(bool f(Transform element)) => IterableMixinWorkaround.every(this, f );
8265 8285
8266 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f); 8286 bool any(bool f(Transform element)) => IterableMixinWorkaround.any(this, f);
8267 8287
8268 List<Transform> toList() => new List<Transform>.from(this); 8288 List<Transform> toList() => new List<Transform>.from(this);
8269 Set<Transform> toSet() => new Set<Transform>.from(this); 8289 Set<Transform> toSet() => new Set<Transform>.from(this);
8270 8290
8271 bool get isEmpty => this.length == 0; 8291 bool get isEmpty => this.length == 0;
8272 8292
8273 List<Transform> take(int n) => IterableMixinWorkaround.takeList(this, n); 8293 Iterable<Transform> take(int n) => IterableMixinWorkaround.takeList(this, n);
8274 8294
8275 Iterable<Transform> takeWhile(bool test(Transform value)) { 8295 Iterable<Transform> takeWhile(bool test(Transform value)) {
8276 return IterableMixinWorkaround.takeWhile(this, test); 8296 return IterableMixinWorkaround.takeWhile(this, test);
8277 } 8297 }
8278 8298
8279 List<Transform> skip(int n) => IterableMixinWorkaround.skipList(this, n); 8299 Iterable<Transform> skip(int n) => IterableMixinWorkaround.skipList(this, n);
8280 8300
8281 Iterable<Transform> skipWhile(bool test(Transform value)) { 8301 Iterable<Transform> skipWhile(bool test(Transform value)) {
8282 return IterableMixinWorkaround.skipWhile(this, test); 8302 return IterableMixinWorkaround.skipWhile(this, test);
8283 } 8303 }
8284 8304
8285 Transform firstMatching(bool test(Transform value), { Transform orElse() }) { 8305 Transform firstMatching(bool test(Transform value), { Transform orElse() }) {
8286 return IterableMixinWorkaround.firstMatching(this, test, orElse); 8306 return IterableMixinWorkaround.firstMatching(this, test, orElse);
8287 } 8307 }
8288 8308
8289 Transform lastMatching(bool test(Transform value), {Transform orElse()}) { 8309 Transform lastMatching(bool test(Transform value), {Transform orElse()}) {
(...skipping 552 matching lines...) Expand 10 before | Expand all | Expand 10 after
8842 return IterableMixinWorkaround.reduce(this, initialValue, combine); 8862 return IterableMixinWorkaround.reduce(this, initialValue, combine);
8843 } 8863 }
8844 8864
8845 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element); 8865 bool contains(ElementInstance element) => IterableMixinWorkaround.contains(thi s, element);
8846 8866
8847 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f); 8867 void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEa ch(this, f);
8848 8868
8849 String join([String separator]) => 8869 String join([String separator]) =>
8850 IterableMixinWorkaround.joinList(this, separator); 8870 IterableMixinWorkaround.joinList(this, separator);
8851 8871
8852 List mappedBy(f(ElementInstance element)) => IterableMixinWorkaround.mappedByL ist(this, f); 8872 Iterable map(f(ElementInstance element)) =>
8873 IterableMixinWorkaround.map(this, f);
8874
8875 List mappedBy(f(ElementInstance element)) =>
8876 IterableMixinWorkaround.mappedByList(this, f);
8853 8877
8854 Iterable<ElementInstance> where(bool f(ElementInstance element)) => 8878 Iterable<ElementInstance> where(bool f(ElementInstance element)) =>
8855 IterableMixinWorkaround.where(this, f); 8879 IterableMixinWorkaround.where(this, f);
8856 8880
8857 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f); 8881 bool every(bool f(ElementInstance element)) => IterableMixinWorkaround.every(t his, f);
8858 8882
8859 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f); 8883 bool any(bool f(ElementInstance element)) => IterableMixinWorkaround.any(this, f);
8860 8884
8861 List<ElementInstance> toList() => new List<ElementInstance>.from(this); 8885 List<ElementInstance> toList() => new List<ElementInstance>.from(this);
8862 Set<ElementInstance> toSet() => new Set<ElementInstance>.from(this); 8886 Set<ElementInstance> toSet() => new Set<ElementInstance>.from(this);
8863 8887
8864 bool get isEmpty => this.length == 0; 8888 bool get isEmpty => this.length == 0;
8865 8889
8866 List<ElementInstance> take(int n) => IterableMixinWorkaround.takeList(this, n) ; 8890 Iterable<ElementInstance> take(int n) => IterableMixinWorkaround.takeList(this , n);
8867 8891
8868 Iterable<ElementInstance> takeWhile(bool test(ElementInstance value)) { 8892 Iterable<ElementInstance> takeWhile(bool test(ElementInstance value)) {
8869 return IterableMixinWorkaround.takeWhile(this, test); 8893 return IterableMixinWorkaround.takeWhile(this, test);
8870 } 8894 }
8871 8895
8872 List<ElementInstance> skip(int n) => IterableMixinWorkaround.skipList(this, n) ; 8896 Iterable<ElementInstance> skip(int n) => IterableMixinWorkaround.skipList(this , n);
8873 8897
8874 Iterable<ElementInstance> skipWhile(bool test(ElementInstance value)) { 8898 Iterable<ElementInstance> skipWhile(bool test(ElementInstance value)) {
8875 return IterableMixinWorkaround.skipWhile(this, test); 8899 return IterableMixinWorkaround.skipWhile(this, test);
8876 } 8900 }
8877 8901
8878 ElementInstance firstMatching(bool test(ElementInstance value), { ElementInsta nce orElse() }) { 8902 ElementInstance firstMatching(bool test(ElementInstance value), { ElementInsta nce orElse() }) {
8879 return IterableMixinWorkaround.firstMatching(this, test, orElse); 8903 return IterableMixinWorkaround.firstMatching(this, test, orElse);
8880 } 8904 }
8881 8905
8882 ElementInstance lastMatching(bool test(ElementInstance value), {ElementInstanc e orElse()}) { 8906 ElementInstance lastMatching(bool test(ElementInstance value), {ElementInstanc e orElse()}) {
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after
8995 List<ElementInstance> getRange(int start, int rangeLength) => 9019 List<ElementInstance> getRange(int start, int rangeLength) =>
8996 Lists.getRange(this, start, rangeLength, <ElementInstance>[]); 9020 Lists.getRange(this, start, rangeLength, <ElementInstance>[]);
8997 9021
8998 // -- end List<ElementInstance> mixins. 9022 // -- end List<ElementInstance> mixins.
8999 9023
9000 @DomName('SVGElementInstanceList.item') 9024 @DomName('SVGElementInstanceList.item')
9001 @DocsEditable 9025 @DocsEditable
9002 ElementInstance item(int index) native "SVGElementInstanceList_item_Callback"; 9026 ElementInstance item(int index) native "SVGElementInstanceList_item_Callback";
9003 9027
9004 } 9028 }
OLDNEW
« no previous file with comments | « sdk/lib/svg/dart2js/svg_dart2js.dart ('k') | tests/compiler/dart2js/type_checker_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698