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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/dart_codegen/expect/convert/json.dart

Issue 963593002: Disable formatting and add new-lines to make tests faster. (Closed) Base URL: git@github.com:dart-lang/dev_compiler.git@master
Patch Set: Created 5 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
« test/dart_codegen/expect/_internal/iterable.dart ('K') | « test/dart_codegen/expect/convert/html_escape.dart ('k') | test/dart_codegen/expect/convert/latin1.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 part of dart.convert; 1 part of dart.convert;
2 2 class JsonUnsupportedObjectError extends Error {final unsupportedObject;
3 class JsonUnsupportedObjectError extends Error { 3 final cause;
4 final unsupportedObject; 4 JsonUnsupportedObjectError(this.unsupportedObject, {
5 final cause; 5 this.cause}
6 JsonUnsupportedObjectError(this.unsupportedObject, {this.cause}); 6 );
7 String toString() { 7 String toString() {
8 if (cause != null) { 8 if (cause != null) {
9 return "Converting object to an encodable object failed."; 9 return "Converting object to an encodable object failed.";
10 } else { 10 }
11 return "Converting object did not return an encodable object."; 11 else {
12 return "Converting object did not return an encodable object.";
12 } 13 }
13 } 14 }
14 } 15 }
15 class JsonCyclicError extends JsonUnsupportedObjectError { 16 class JsonCyclicError extends JsonUnsupportedObjectError {JsonCyclicError(Objec t object) : super(object);
16 JsonCyclicError(Object object) : super(object); 17 String toString() => "Cyclic error in JSON stringify";
17 String toString() => "Cyclic error in JSON stringify"; 18 }
18 } 19 const JsonCodec JSON = const JsonCodec();
19 const JsonCodec JSON = const JsonCodec(); 20 typedef _Reviver(var key, var value);
20 typedef _Reviver(var key, var value); 21 typedef _ToEncodable(var o);
21 typedef _ToEncodable(var o); 22 class JsonCodec extends Codec<Object, String> {final _Reviver _reviver;
22 class JsonCodec extends Codec<Object, String> { 23 final _ToEncodable _toEncodable;
23 final _Reviver _reviver; 24 const JsonCodec({
24 final _ToEncodable _toEncodable; 25 reviver(var key, var value), toEncodable(var object)}
25 const JsonCodec({reviver(var key, var value), toEncodable(var object)}) 26 ) : _reviver = reviver, _toEncodable = toEncodable;
26 : _reviver = reviver, 27 JsonCodec.withReviver(reviver(var key, var value)) : this(reviver: reviver);
27 _toEncodable = toEncodable; 28 dynamic decode(String source, {
28 JsonCodec.withReviver(reviver(var key, var value)) : this(reviver: reviver); 29 reviver(var key, var value)}
29 dynamic decode(String source, {reviver(var key, var value)}) { 30 ) {
30 if (reviver == null) reviver = _reviver; 31 if (reviver == null) reviver = _reviver;
31 if (reviver == null) return decoder.convert(source); 32 if (reviver == null) return decoder.convert(source);
32 return new JsonDecoder(reviver).convert(source); 33 return new JsonDecoder(reviver).convert(source);
33 } 34 }
34 String encode(Object value, {toEncodable(var object)}) { 35 String encode(Object value, {
35 if (toEncodable == null) toEncodable = _toEncodable; 36 toEncodable(var object)}
36 if (toEncodable == null) return encoder.convert(value); 37 ) {
37 return new JsonEncoder(toEncodable).convert(value); 38 if (toEncodable == null) toEncodable = _toEncodable;
38 } 39 if (toEncodable == null) return encoder.convert(value);
39 JsonEncoder get encoder { 40 return new JsonEncoder(toEncodable).convert(value);
40 if (_toEncodable == null) return const JsonEncoder(); 41 }
41 return new JsonEncoder(_toEncodable); 42 JsonEncoder get encoder {
42 } 43 if (_toEncodable == null) return const JsonEncoder();
43 JsonDecoder get decoder { 44 return new JsonEncoder(_toEncodable);
44 if (_reviver == null) return const JsonDecoder(); 45 }
45 return new JsonDecoder(_reviver); 46 JsonDecoder get decoder {
46 } 47 if (_reviver == null) return const JsonDecoder();
47 } 48 return new JsonDecoder(_reviver);
48 class JsonEncoder extends Converter<Object, String> { 49 }
49 final String indent; 50 }
50 final Function _toEncodable; 51 class JsonEncoder extends Converter<Object, String> {final String indent;
51 const JsonEncoder([Object toEncodable(Object nonSerializable)]) 52 final Function _toEncodable;
52 : this.indent = null, 53 const JsonEncoder([Object toEncodable(Object nonSerializable)]) : this.indent = null, this._toEncodable = toEncodable;
53 this._toEncodable = toEncodable; 54 const JsonEncoder.withIndent(this.indent, [Object toEncodable(Object nonSeriali zable)]) : this._toEncodable = toEncodable;
54 const JsonEncoder.withIndent(this.indent, 55 String convert(Object object) => _JsonStringStringifier.stringify(object, DDC$R T.cast(_toEncodable, Function, __t7, "CastGeneral", """line 243, column 48 of da rt:convert/json.dart: """, _toEncodable is __t7, false), indent);
55 [Object toEncodable(Object nonSerializable)]) 56 ChunkedConversionSink<Object> startChunkedConversion(Sink<String> sink) {
56 : this._toEncodable = toEncodable; 57 if (sink is! StringConversionSink) {
57 String convert(Object object) => _JsonStringStringifier.stringify(object, 58 sink = new StringConversionSink.from(sink);
58 DDC$RT.cast(_toEncodable, Function, __t7, "CastGeneral", 59 }
59 """line 243, column 48 of dart:convert/json.dart: """, 60 else if (sink is _Utf8EncoderSink) {
60 _toEncodable is __t7, false), indent); 61 return new _JsonUtf8EncoderSink(sink._sink, _toEncodable, JsonUtf8Encoder._utf8E ncode(indent), JsonUtf8Encoder.DEFAULT_BUFFER_SIZE);
61 ChunkedConversionSink<Object> startChunkedConversion(Sink<String> sink) { 62 }
62 if (sink is! StringConversionSink) { 63 return new _JsonEncoderSink(sink, _toEncodable, indent);
63 sink = new StringConversionSink.from(sink); 64 }
64 } else if (sink is _Utf8EncoderSink) { 65 Stream<String> bind(Stream<Object> stream) => ((__x9) => DDC$RT.cast(__x9, DDC$ RT.type((DDC$async$.Stream<dynamic> _) {
65 return new _JsonUtf8EncoderSink(sink._sink, _toEncodable, 66 }
66 JsonUtf8Encoder._utf8Encode(indent), 67 ), DDC$RT.type((DDC$async$.Stream<String> _) {
67 JsonUtf8Encoder.DEFAULT_BUFFER_SIZE); 68 }
68 } 69 ), "CastDynamic", """line 266, column 49 of dart:convert/json.dart: """, __x9 is DDC$async$.Stream<String>, false))(super.bind(stream));
69 return new _JsonEncoderSink(sink, _toEncodable, indent); 70 Converter<Object, dynamic> fuse(Converter<String, dynamic> other) {
70 } 71 if (other is Utf8Encoder) {
71 Stream<String> bind(Stream<Object> stream) => ((__x9) => DDC$RT.cast(__x9, 72 return new JsonUtf8Encoder(indent, _toEncodable);
72 DDC$RT.type((DDC$async$.Stream<dynamic> _) {}), 73 }
73 DDC$RT.type((DDC$async$.Stream<String> _) {}), "CastDynamic", 74 return super.fuse(other);
74 """line 266, column 49 of dart:convert/json.dart: """, 75 }
75 __x9 is DDC$async$.Stream<String>, false))(super.bind(stream)); 76 }
76 Converter<Object, dynamic> fuse(Converter<String, dynamic> other) { 77 class JsonUtf8Encoder extends Converter<Object, List<int>> {static const int DE FAULT_BUFFER_SIZE = 256;
77 if (other is Utf8Encoder) { 78 final List<int> _indent;
78 return new JsonUtf8Encoder(indent, _toEncodable); 79 final Function _toEncodable;
79 } 80 final int _bufferSize;
80 return super.fuse(other); 81 JsonUtf8Encoder([String indent, toEncodable(Object object), int bufferSize = DE FAULT_BUFFER_SIZE]) : _indent = _utf8Encode(indent), _toEncodable = toEncodable, _bufferSize = bufferSize;
81 } 82 static List<int> _utf8Encode(String string) {
82 } 83 if (string == null) return null;
83 class JsonUtf8Encoder extends Converter<Object, List<int>> { 84 if (string.isEmpty) return new Uint8List(0);
84 static const int DEFAULT_BUFFER_SIZE = 256; 85 checkAscii: {
85 final List<int> _indent; 86 for (int i = 0;
86 final Function _toEncodable; 87 i < string.length;
87 final int _bufferSize; 88 i++) {
88 JsonUtf8Encoder([String indent, toEncodable(Object object), 89 if (string.codeUnitAt(i) >= 0x80) break checkAscii;
89 int bufferSize = DEFAULT_BUFFER_SIZE]) 90 }
90 : _indent = _utf8Encode(indent), 91 return string.codeUnits;
91 _toEncodable = toEncodable, 92 }
92 _bufferSize = bufferSize; 93 return UTF8.encode(string);
93 static List<int> _utf8Encode(String string) { 94 }
94 if (string == null) return null; 95 List<int> convert(Object object) {
95 if (string.isEmpty) return new Uint8List(0); 96 List<List<int>> bytes = ((__x10) => DDC$RT.cast(__x10, DDC$RT.type((List<dynamic > _) {
96 checkAscii: { 97 }
97 for (int i = 0; i < string.length; i++) { 98 ), DDC$RT.type((List<List<int>> _) {
98 if (string.codeUnitAt(i) >= 0x80) break checkAscii; 99 }
99 } 100 ), "CastLiteral", """line 338, column 29 of dart:convert/json.dart: """, __x10 i s List<List<int>>, false))([]);
100 return string.codeUnits; 101 void addChunk(Uint8List chunk, int start, int end) {
101 } 102 if (start > 0 || end < chunk.length) {
102 return UTF8.encode(string); 103 int length = end - start;
103 } 104 chunk = new Uint8List.view(chunk.buffer, chunk.offsetInBytes + start, length);
104 List<int> convert(Object object) { 105 }
105 List<List<int>> bytes = ((__x10) => DDC$RT.cast(__x10, 106 bytes.add(chunk);
106 DDC$RT.type((List<dynamic> _) {}), DDC$RT.type((List<List<int>> _) {}), 107 }
107 "CastLiteral", """line 338, column 29 of dart:convert/json.dart: """, 108 _JsonUtf8Stringifier.stringify(object, _indent, DDC$RT.cast(_toEncodable, Funct ion, __t11, "CastGeneral", """line 352, column 36 of dart:convert/json.dart: """ , _toEncodable is __t11, false), _bufferSize, addChunk);
108 __x10 is List<List<int>>, false))([]); 109 if (bytes.length == 1) return bytes[0];
109 void addChunk(Uint8List chunk, int start, int end) { 110 int length = 0;
110 if (start > 0 || end < chunk.length) { 111 for (int i = 0;
111 int length = end - start; 112 i < bytes.length;
112 chunk = new Uint8List.view( 113 i++) {
113 chunk.buffer, chunk.offsetInBytes + start, length); 114 length += bytes[i].length;
114 } 115 }
115 bytes.add(chunk); 116 Uint8List result = new Uint8List(length);
116 } 117 for (int i = 0, offset = 0;
117 _JsonUtf8Stringifier.stringify(object, _indent, DDC$RT.cast(_toEncodable, 118 i < bytes.length;
118 Function, __t11, "CastGeneral", 119 i++) {
119 """line 352, column 36 of dart:convert/json.dart: """, 120 var byteList = bytes[i];
120 _toEncodable is __t11, false), _bufferSize, addChunk); 121 int end = offset + byteList.length;
121 if (bytes.length == 1) return bytes[0]; 122 result.setRange(offset, end, byteList);
122 int length = 0; 123 offset = end;
123 for (int i = 0; i < bytes.length; i++) { 124 }
124 length += bytes[i].length; 125 return result;
125 } 126 }
126 Uint8List result = new Uint8List(length); 127 ChunkedConversionSink<Object> startChunkedConversion(Sink<List<int>> sink) {
127 for (int i = 0, offset = 0; i < bytes.length; i++) { 128 ByteConversionSink byteSink;
128 var byteList = bytes[i]; 129 if (sink is ByteConversionSink) {
129 int end = offset + byteList.length; 130 byteSink = sink;
130 result.setRange(offset, end, byteList); 131 }
131 offset = end; 132 else {
132 } 133 byteSink = new ByteConversionSink.from(sink);
133 return result; 134 }
134 } 135 return new _JsonUtf8EncoderSink(byteSink, _toEncodable, _indent, _bufferSize);
135 ChunkedConversionSink<Object> startChunkedConversion(Sink<List<int>> sink) { 136 }
136 ByteConversionSink byteSink; 137 Stream<List<int>> bind(Stream<Object> stream) {
137 if (sink is ByteConversionSink) { 138 return ((__x13) => DDC$RT.cast(__x13, DDC$RT.type((DDC$async$.Stream<dynamic> _) {
138 byteSink = sink; 139 }
139 } else { 140 ), DDC$RT.type((DDC$async$.Stream<List<int>> _) {
140 byteSink = new ByteConversionSink.from(sink); 141 }
141 } 142 ), "CastDynamic", """line 391, column 12 of dart:convert/json.dart: """, __x13 i s DDC$async$.Stream<List<int>>, false))(super.bind(stream));
142 return new _JsonUtf8EncoderSink( 143 }
143 byteSink, _toEncodable, _indent, _bufferSize); 144 Converter<Object, dynamic> fuse(Converter<List<int>, dynamic> other) {
144 } 145 return super.fuse(other);
145 Stream<List<int>> bind(Stream<Object> stream) { 146 }
146 return ((__x13) => DDC$RT.cast(__x13, 147 }
147 DDC$RT.type((DDC$async$.Stream<dynamic> _) {}), 148 class _JsonEncoderSink extends ChunkedConversionSink<Object> {final String _ind ent;
148 DDC$RT.type((DDC$async$.Stream<List<int>> _) {}), "CastDynamic", 149 final Function _toEncodable;
149 """line 391, column 12 of dart:convert/json.dart: """, 150 final StringConversionSink _sink;
150 __x13 is DDC$async$.Stream<List<int>>, false))(super.bind(stream)); 151 bool _isDone = false;
151 } 152 _JsonEncoderSink(this._sink, this._toEncodable, this._indent);
152 Converter<Object, dynamic> fuse(Converter<List<int>, dynamic> other) { 153 void add(Object o) {
153 return super.fuse(other); 154 if (_isDone) {
154 } 155 throw new StateError("Only one call to add allowed");
155 } 156 }
156 class _JsonEncoderSink extends ChunkedConversionSink<Object> { 157 _isDone = true;
157 final String _indent; 158 ClosableStringSink stringSink = _sink.asStringSink();
158 final Function _toEncodable; 159 _JsonStringStringifier.printOn(o, stringSink, DDC$RT.cast(_toEncodable, Functio n, __t7, "CastGeneral", """line 425, column 51 of dart:convert/json.dart: """, _ toEncodable is __t7, false), _indent);
159 final StringConversionSink _sink; 160 stringSink.close();
160 bool _isDone = false; 161 }
161 _JsonEncoderSink(this._sink, this._toEncodable, this._indent); 162 void close() {
162 void add(Object o) { 163 }
163 if (_isDone) { 164 }
164 throw new StateError("Only one call to add allowed"); 165 class _JsonUtf8EncoderSink extends ChunkedConversionSink<Object> {final ByteCon versionSink _sink;
165 } 166 final List<int> _indent;
166 _isDone = true; 167 final Function _toEncodable;
167 ClosableStringSink stringSink = _sink.asStringSink(); 168 final int _bufferSize;
168 _JsonStringStringifier.printOn(o, stringSink, DDC$RT.cast(_toEncodable, 169 bool _isDone = false;
169 Function, __t7, "CastGeneral", 170 _JsonUtf8EncoderSink(this._sink, this._toEncodable, this._indent, this._bufferS ize);
170 """line 425, column 51 of dart:convert/json.dart: """, 171 void _addChunk(Uint8List chunk, int start, int end) {
171 _toEncodable is __t7, false), _indent); 172 _sink.addSlice(chunk, start, end, false);
172 stringSink.close(); 173 }
173 } 174 void add(Object object) {
174 void close() {} 175 if (_isDone) {
175 } 176 throw new StateError("Only one call to add allowed");
176 class _JsonUtf8EncoderSink extends ChunkedConversionSink<Object> { 177 }
177 final ByteConversionSink _sink; 178 _isDone = true;
178 final List<int> _indent; 179 _JsonUtf8Stringifier.stringify(object, _indent, DDC$RT.cast(_toEncodable, Funct ion, __t11, "CastGeneral", """line 455, column 53 of dart:convert/json.dart: """ , _toEncodable is __t11, false), _bufferSize, _addChunk);
179 final Function _toEncodable; 180 _sink.close();
180 final int _bufferSize; 181 }
181 bool _isDone = false; 182 void close() {
182 _JsonUtf8EncoderSink( 183 if (!_isDone) {
183 this._sink, this._toEncodable, this._indent, this._bufferSize); 184 _isDone = true;
184 void _addChunk(Uint8List chunk, int start, int end) { 185 _sink.close();
185 _sink.addSlice(chunk, start, end, false); 186 }
186 } 187 }
187 void add(Object object) { 188 }
188 if (_isDone) { 189 class JsonDecoder extends Converter<String, Object> {final _Reviver _reviver;
189 throw new StateError("Only one call to add allowed"); 190 const JsonDecoder([reviver(var key, var value)]) : this._reviver = reviver;
190 } 191 dynamic convert(String input) => _parseJson(input, _reviver);
191 _isDone = true; 192 StringConversionSink startChunkedConversion(Sink<Object> sink) {
192 _JsonUtf8Stringifier.stringify(object, _indent, DDC$RT.cast(_toEncodable, 193 return new _JsonDecoderSink(_reviver, sink);
193 Function, __t11, "CastGeneral", 194 }
194 """line 455, column 53 of dart:convert/json.dart: """, 195 Stream<Object> bind(Stream<String> stream) => ((__x14) => DDC$RT.cast(__x14, DD C$RT.type((DDC$async$.Stream<dynamic> _) {
195 _toEncodable is __t11, false), _bufferSize, _addChunk); 196 }
196 _sink.close(); 197 ), DDC$RT.type((DDC$async$.Stream<Object> _) {
197 } 198 }
198 void close() { 199 ), "CastDynamic", """line 509, column 49 of dart:convert/json.dart: """, __x14 i s DDC$async$.Stream<Object>, false))(super.bind(stream));
199 if (!_isDone) { 200 }
200 _isDone = true; 201 _parseJson(String source, reviver(key, value)) {
201 _sink.close(); 202 if (source is! String) throw new ArgumentError(source);
202 } 203 var parsed;
203 } 204 try {
204 } 205 parsed = JS('=Object|JSExtendableArray|Null|bool|num|String', 'JSON.parse(#)', s ource);
205 class JsonDecoder extends Converter<String, Object> { 206 }
206 final _Reviver _reviver; 207 catch (e) {
207 const JsonDecoder([reviver(var key, var value)]) : this._reviver = reviver; 208 throw new FormatException(JS('String', 'String(#)', e));
208 dynamic convert(String input) => _parseJson(input, _reviver); 209 }
209 StringConversionSink startChunkedConversion(Sink<Object> sink) { 210 if (reviver == null) {
210 return new _JsonDecoderSink(_reviver, sink); 211 return _convertJsonToDartLazy(parsed);
211 } 212 }
212 Stream<Object> bind(Stream<String> stream) => ((__x14) => DDC$RT.cast(__x14, 213 else {
213 DDC$RT.type((DDC$async$.Stream<dynamic> _) {}), 214 return _convertJsonToDart(parsed, reviver);
214 DDC$RT.type((DDC$async$.Stream<Object> _) {}), "CastDynamic", 215 }
215 """line 509, column 49 of dart:convert/json.dart: """, 216 }
216 __x14 is DDC$async$.Stream<Object>, false))(super.bind(stream)); 217 Object _defaultToEncodable(object) => object.toJson();
217 } 218 abstract class _JsonStringifier {static const int BACKSPACE = 0x08;
218 _parseJson(String source, reviver(key, value)) { 219 static const int TAB = 0x09;
219 if (source is! String) throw new ArgumentError(source); 220 static const int NEWLINE = 0x0a;
220 var parsed; 221 static const int CARRIAGE_RETURN = 0x0d;
221 try { 222 static const int FORM_FEED = 0x0c;
222 parsed = JS('=Object|JSExtendableArray|Null|bool|num|String', 223 static const int QUOTE = 0x22;
223 'JSON.parse(#)', source); 224 static const int CHAR_0 = 0x30;
224 } catch (e) { 225 static const int BACKSLASH = 0x5c;
225 throw new FormatException(JS('String', 'String(#)', e)); 226 static const int CHAR_b = 0x62;
226 } 227 static const int CHAR_f = 0x66;
227 if (reviver == null) { 228 static const int CHAR_n = 0x6e;
228 return _convertJsonToDartLazy(parsed); 229 static const int CHAR_r = 0x72;
229 } else { 230 static const int CHAR_t = 0x74;
230 return _convertJsonToDart(parsed, reviver); 231 static const int CHAR_u = 0x75;
231 } 232 final List _seen = new List();
232 } 233 final Function _toEncodable;
233 Object _defaultToEncodable(object) => object.toJson(); 234 _JsonStringifier(Object _toEncodable(Object o)) : _toEncodable = (_toEncodable != null) ? _toEncodable : _defaultToEncodable;
234 abstract class _JsonStringifier { 235 void writeString(String characters);
235 static const int BACKSPACE = 0x08; 236 void writeStringSlice(String characters, int start, int end);
236 static const int TAB = 0x09; 237 void writeCharCode(int charCode);
237 static const int NEWLINE = 0x0a; 238 void writeNumber(num number);
238 static const int CARRIAGE_RETURN = 0x0d; 239 static int hexDigit(int x) => x < 10 ? 48 + x : 87 + x;
239 static const int FORM_FEED = 0x0c; 240 void writeStringContent(String s) {
240 static const int QUOTE = 0x22; 241 int offset = 0;
241 static const int CHAR_0 = 0x30; 242 final int length = s.length;
242 static const int BACKSLASH = 0x5c; 243 for (int i = 0;
243 static const int CHAR_b = 0x62; 244 i < length;
244 static const int CHAR_f = 0x66; 245 i++) {
245 static const int CHAR_n = 0x6e; 246 int charCode = s.codeUnitAt(i);
246 static const int CHAR_r = 0x72; 247 if (charCode > BACKSLASH) continue;
247 static const int CHAR_t = 0x74; 248 if (charCode < 32) {
248 static const int CHAR_u = 0x75; 249 if (i > offset) writeStringSlice(s, offset, i);
249 final List _seen = new List(); 250 offset = i + 1;
250 final Function _toEncodable; 251 writeCharCode(BACKSLASH);
251 _JsonStringifier(Object _toEncodable(Object o)) 252 switch (charCode) {case BACKSPACE: writeCharCode(CHAR_b);
252 : _toEncodable = (_toEncodable != null) 253 break;
253 ? _toEncodable 254 case TAB: writeCharCode(CHAR_t);
254 : _defaultToEncodable; 255 break;
255 void writeString(String characters); 256 case NEWLINE: writeCharCode(CHAR_n);
256 void writeStringSlice(String characters, int start, int end); 257 break;
257 void writeCharCode(int charCode); 258 case FORM_FEED: writeCharCode(CHAR_f);
258 void writeNumber(num number); 259 break;
259 static int hexDigit(int x) => x < 10 ? 48 + x : 87 + x; 260 case CARRIAGE_RETURN: writeCharCode(CHAR_r);
260 void writeStringContent(String s) { 261 break;
261 int offset = 0; 262 default: writeCharCode(CHAR_u);
262 final int length = s.length; 263 writeCharCode(CHAR_0);
263 for (int i = 0; i < length; i++) { 264 writeCharCode(CHAR_0);
264 int charCode = s.codeUnitAt(i); 265 writeCharCode(hexDigit((charCode >> 4) & 0xf));
265 if (charCode > BACKSLASH) continue; 266 writeCharCode(hexDigit(charCode & 0xf));
266 if (charCode < 32) { 267 break;
267 if (i > offset) writeStringSlice(s, offset, i); 268 }
268 offset = i + 1; 269 }
269 writeCharCode(BACKSLASH); 270 else if (charCode == QUOTE || charCode == BACKSLASH) {
270 switch (charCode) { 271 if (i > offset) writeStringSlice(s, offset, i);
271 case BACKSPACE: 272 offset = i + 1;
272 writeCharCode(CHAR_b); 273 writeCharCode(BACKSLASH);
273 break; 274 writeCharCode(charCode);
274 case TAB: 275 }
275 writeCharCode(CHAR_t); 276 }
276 break; 277 if (offset == 0) {
277 case NEWLINE: 278 writeString(s);
278 writeCharCode(CHAR_n); 279 }
279 break; 280 else if (offset < length) {
280 case FORM_FEED: 281 writeStringSlice(s, offset, length);
281 writeCharCode(CHAR_f); 282 }
282 break; 283 }
283 case CARRIAGE_RETURN: 284 void _checkCycle(object) {
284 writeCharCode(CHAR_r); 285 for (int i = 0;
285 break; 286 i < _seen.length;
286 default: 287 i++) {
287 writeCharCode(CHAR_u); 288 if (identical(object, _seen[i])) {
288 writeCharCode(CHAR_0); 289 throw new JsonCyclicError(object);
289 writeCharCode(CHAR_0); 290 }
290 writeCharCode(hexDigit((charCode >> 4) & 0xf)); 291 }
291 writeCharCode(hexDigit(charCode & 0xf)); 292 _seen.add(object);
292 break; 293 }
293 } 294 void _removeSeen(object) {
294 } else if (charCode == QUOTE || charCode == BACKSLASH) { 295 assert (!_seen.isEmpty); assert (identical(_seen.last, object)); _seen.removeLas t();
295 if (i > offset) writeStringSlice(s, offset, i); 296 }
296 offset = i + 1; 297 void writeObject(object) {
297 writeCharCode(BACKSLASH); 298 if (writeJsonValue(object)) return; _checkCycle(object);
298 writeCharCode(charCode); 299 try {
299 } 300 var customJson = _toEncodable(object);
300 } 301 if (!writeJsonValue(customJson)) {
301 if (offset == 0) { 302 throw new JsonUnsupportedObjectError(object);
302 writeString(s); 303 }
303 } else if (offset < length) { 304 _removeSeen(object);
304 writeStringSlice(s, offset, length); 305 }
305 } 306 catch (e) {
306 } 307 throw new JsonUnsupportedObjectError(object, cause: e);
307 void _checkCycle(object) { 308 }
308 for (int i = 0; i < _seen.length; i++) { 309 }
309 if (identical(object, _seen[i])) { 310 bool writeJsonValue(object) {
310 throw new JsonCyclicError(object); 311 if (object is num) {
311 } 312 if (!object.isFinite) return false;
312 } 313 writeNumber(DDC$RT.cast(object, dynamic, num, "CastGeneral", """line 692, colum n 19 of dart:convert/json.dart: """, object is num, true));
313 _seen.add(object); 314 return true;
314 } 315 }
315 void _removeSeen(object) { 316 else if (identical(object, true)) {
316 assert(!_seen.isEmpty); 317 writeString('true');
317 assert(identical(_seen.last, object)); 318 return true;
318 _seen.removeLast(); 319 }
319 } 320 else if (identical(object, false)) {
320 void writeObject(object) { 321 writeString('false');
321 if (writeJsonValue(object)) return; 322 return true;
322 _checkCycle(object); 323 }
323 try { 324 else if (object == null) {
324 var customJson = _toEncodable(object); 325 writeString('null');
325 if (!writeJsonValue(customJson)) { 326 return true;
326 throw new JsonUnsupportedObjectError(object); 327 }
327 } 328 else if (object is String) {
328 _removeSeen(object); 329 writeString('"');
329 } catch (e) { 330 writeStringContent(DDC$RT.cast(object, dynamic, String, "CastGeneral", """line 705, column 26 of dart:convert/json.dart: """, object is String, true));
330 throw new JsonUnsupportedObjectError(object, cause: e); 331 writeString('"');
331 } 332 return true;
332 } 333 }
333 bool writeJsonValue(object) { 334 else if (object is List) {
334 if (object is num) { 335 _checkCycle(object);
335 if (!object.isFinite) return false; 336 writeList(DDC$RT.cast(object, dynamic, DDC$RT.type((List<dynamic> _) {
336 writeNumber(DDC$RT.cast(object, dynamic, num, "CastGeneral", 337 }
337 """line 692, column 19 of dart:convert/json.dart: """, object is num, 338 ), "CastGeneral", """line 710, column 17 of dart:convert/json.dart: """, object is List<dynamic>, true));
338 true)); 339 _removeSeen(object);
339 return true; 340 return true;
340 } else if (identical(object, true)) { 341 }
341 writeString('true'); 342 else if (object is Map) {
342 return true; 343 _checkCycle(object);
343 } else if (identical(object, false)) { 344 writeMap(DDC$RT.cast(object, dynamic, DDC$RT.type((Map<String, Object> _) {
344 writeString('false'); 345 }
345 return true; 346 ), "CastGeneral", """line 715, column 16 of dart:convert/json.dart: """, object is Map<String, Object>, false));
346 } else if (object == null) { 347 _removeSeen(object);
347 writeString('null'); 348 return true;
348 return true; 349 }
349 } else if (object is String) { 350 else {
350 writeString('"'); 351 return false;
351 writeStringContent(DDC$RT.cast(object, dynamic, String, "CastGeneral", 352 }
352 """line 705, column 26 of dart:convert/json.dart: """, 353 }
353 object is String, true)); 354 void writeList(List list) {
354 writeString('"'); 355 writeString('[');
355 return true; 356 if (list.length > 0) {
356 } else if (object is List) { 357 writeObject(list[0]);
357 _checkCycle(object); 358 for (int i = 1;
358 writeList(DDC$RT.cast(object, dynamic, DDC$RT.type((List<dynamic> _) {}), 359 i < list.length;
359 "CastGeneral", """line 710, column 17 of dart:convert/json.dart: """, 360 i++) {
360 object is List<dynamic>, true)); 361 writeString(',');
361 _removeSeen(object); 362 writeObject(list[i]);
362 return true; 363 }
363 } else if (object is Map) { 364 }
364 _checkCycle(object); 365 writeString(']');
365 writeMap(DDC$RT.cast(object, dynamic, 366 }
366 DDC$RT.type((Map<String, Object> _) {}), "CastGeneral", 367 void writeMap(Map<String, Object> map) {
367 """line 715, column 16 of dart:convert/json.dart: """, 368 writeString('{');
368 object is Map<String, Object>, false)); 369 String separator = '"';
369 _removeSeen(object); 370 map.forEach((String key, value) {
370 return true; 371 writeString(separator);
371 } else { 372 separator = ',"';
372 return false; 373 writeStringContent(key);
373 } 374 writeString('":');
374 } 375 writeObject(value);
375 void writeList(List list) { 376 }
376 writeString('['); 377 );
377 if (list.length > 0) { 378 writeString('}');
378 writeObject(list[0]); 379 }
379 for (int i = 1; i < list.length; i++) { 380 }
380 writeString(','); 381 abstract class _JsonPrettyPrintMixin implements _JsonStringifier {int _indentLe vel = 0;
381 writeObject(list[i]); 382 void writeIndentation(indentLevel);
382 } 383 void writeList(List list) {
383 } 384 if (list.isEmpty) {
384 writeString(']'); 385 writeString('[]');
385 } 386 }
386 void writeMap(Map<String, Object> map) { 387 else {
387 writeString('{'); 388 writeString('[\n');
388 String separator = '"'; 389 _indentLevel++;
389 map.forEach((String key, value) { 390 writeIndentation(_indentLevel);
390 writeString(separator); 391 writeObject(list[0]);
391 separator = ',"'; 392 for (int i = 1;
392 writeStringContent(key); 393 i < list.length;
393 writeString('":'); 394 i++) {
394 writeObject(value); 395 writeString(',\n');
395 }); 396 writeIndentation(_indentLevel);
396 writeString('}'); 397 writeObject(list[i]);
397 } 398 }
398 } 399 writeString('\n');
399 abstract class _JsonPrettyPrintMixin implements _JsonStringifier { 400 _indentLevel--;
400 int _indentLevel = 0; 401 writeIndentation(_indentLevel);
401 void writeIndentation(indentLevel); 402 writeString(']');
402 void writeList(List list) { 403 }
403 if (list.isEmpty) { 404 }
404 writeString('[]'); 405 void writeMap(Map map) {
405 } else { 406 if (map.isEmpty) {
406 writeString('[\n'); 407 writeString('{}');
407 _indentLevel++; 408 }
408 writeIndentation(_indentLevel); 409 else {
409 writeObject(list[0]); 410 writeString('{\n');
410 for (int i = 1; i < list.length; i++) { 411 _indentLevel++;
411 writeString(',\n'); 412 bool first = true;
412 writeIndentation(_indentLevel); 413 map.forEach(((__x23) => DDC$RT.wrap((dynamic f(String __u15, Object __u16)) {
413 writeObject(list[i]); 414 dynamic c(String x0, Object x1) => f(DDC$RT.cast(x0, dynamic, String, "CastParam ", """line 792, column 19 of dart:convert/json.dart: """, x0 is String, true), x 1);
414 } 415 return f == null ? null : c;
415 writeString('\n'); 416 }
416 _indentLevel--; 417 , __x23, __t20, __t17, "WrapLiteral", """line 792, column 19 of dart:convert/jso n.dart: """, __x23 is __t17))((String key, Object value) {
417 writeIndentation(_indentLevel); 418 if (!first) {
418 writeString(']'); 419 writeString(",\n");
419 } 420 }
420 } 421 writeIndentation(_indentLevel);
421 void writeMap(Map map) { 422 writeString('"');
422 if (map.isEmpty) { 423 writeStringContent(key);
423 writeString('{}'); 424 writeString('": ');
424 } else { 425 writeObject(value);
425 writeString('{\n'); 426 first = false;
426 _indentLevel++; 427 }
427 bool first = true; 428 ));
428 map.forEach(((__x23) => DDC$RT.wrap( 429 writeString('\n');
429 (dynamic f(String __u15, Object __u16)) { 430 _indentLevel--;
430 dynamic c(String x0, Object x1) => f(DDC$RT.cast(x0, dynamic, String, 431 writeIndentation(_indentLevel);
431 "CastParam", """line 792, column 19 of dart:convert/json.dart: """, 432 writeString('}');
432 x0 is String, true), x1); 433 }
433 return f == null ? null : c; 434 }
434 }, __x23, __t20, __t17, "WrapLiteral", 435 }
435 """line 792, column 19 of dart:convert/json.dart: """, 436 class _JsonStringStringifier extends _JsonStringifier {final StringSink _sink;
436 __x23 is __t17))((String key, Object value) { 437 _JsonStringStringifier(this._sink, _toEncodable) : super(DDC$RT.cast(_toEncodab le, dynamic, __t24, "CastGeneral", """line 817, column 60 of dart:convert/json.d art: """, _toEncodable is __t24, false));
437 if (!first) { 438 static String stringify(object, toEncodable(object), String indent) {
438 writeString(",\n"); 439 StringBuffer output = new StringBuffer();
439 } 440 printOn(object, output, toEncodable, indent);
440 writeIndentation(_indentLevel); 441 return output.toString();
441 writeString('"'); 442 }
442 writeStringContent(key); 443 static void printOn(object, StringSink output, toEncodable(object), String inde nt) {
443 writeString('": '); 444 var stringifier;
444 writeObject(value); 445 if (indent == null) {
445 first = false; 446 stringifier = new _JsonStringStringifier(output, toEncodable);
446 })); 447 }
447 writeString('\n'); 448 else {
448 _indentLevel--; 449 stringifier = new _JsonStringStringifierPretty(output, toEncodable, indent);
449 writeIndentation(_indentLevel); 450 }
450 writeString('}'); 451 stringifier.writeObject(object);
451 } 452 }
452 } 453 void writeNumber(num number) {
453 } 454 _sink.write(number.toString());
454 class _JsonStringStringifier extends _JsonStringifier { 455 }
455 final StringSink _sink; 456 void writeString(String string) {
456 _JsonStringStringifier(this._sink, _toEncodable) : super(DDC$RT.cast( 457 _sink.write(string);
457 _toEncodable, dynamic, __t24, "CastGeneral", 458 }
458 """line 817, column 60 of dart:convert/json.dart: """, 459 void writeStringSlice(String string, int start, int end) {
459 _toEncodable is __t24, false)); 460 _sink.write(string.substring(start, end));
460 static String stringify(object, toEncodable(object), String indent) { 461 }
461 StringBuffer output = new StringBuffer(); 462 void writeCharCode(int charCode) {
462 printOn(object, output, toEncodable, indent); 463 _sink.writeCharCode(charCode);
463 return output.toString(); 464 }
464 } 465 }
465 static void printOn( 466 class _JsonStringStringifierPretty extends _JsonStringStringifier with _JsonPre ttyPrintMixin {final String _indent;
466 object, StringSink output, toEncodable(object), String indent) { 467 _JsonStringStringifierPretty(StringSink sink, Function toEncodable, this._inden t) : super(sink, toEncodable);
467 var stringifier; 468 void writeIndentation(int count) {
468 if (indent == null) { 469 for (int i = 0;
469 stringifier = new _JsonStringStringifier(output, toEncodable); 470 i < count;
470 } else { 471 i++) writeString(_indent);
471 stringifier = 472 }
472 new _JsonStringStringifierPretty(output, toEncodable, indent); 473 }
473 } 474 class _JsonUtf8Stringifier extends _JsonStringifier {final int bufferSize;
474 stringifier.writeObject(object); 475 final Function addChunk;
475 } 476 Uint8List buffer;
476 void writeNumber(num number) { 477 int index = 0;
477 _sink.write(number.toString()); 478 _JsonUtf8Stringifier(toEncodable, int bufferSize, this.addChunk) : super(DDC$RT .cast(toEncodable, dynamic, __t24, "CastGeneral", """line 893, column 15 of dart :convert/json.dart: """, toEncodable is __t24, false)), this.bufferSize = buffer Size, buffer = new Uint8List(bufferSize);
478 } 479 static void stringify(Object object, List<int> indent, toEncodableFunction(Obje ct o), int bufferSize, void addChunk(Uint8List chunk, int start, int end)) {
479 void writeString(String string) { 480 _JsonUtf8Stringifier stringifier;
480 _sink.write(string); 481 if (indent != null) {
481 } 482 stringifier = new _JsonUtf8StringifierPretty(toEncodableFunction, indent, buffer Size, addChunk);
482 void writeStringSlice(String string, int start, int end) { 483 }
483 _sink.write(string.substring(start, end)); 484 else {
484 } 485 stringifier = new _JsonUtf8Stringifier(toEncodableFunction, bufferSize, addChunk );
485 void writeCharCode(int charCode) { 486 }
486 _sink.writeCharCode(charCode); 487 stringifier.writeObject(object);
487 } 488 stringifier.flush();
488 } 489 }
489 class _JsonStringStringifierPretty extends _JsonStringStringifier 490 void flush() {
490 with _JsonPrettyPrintMixin { 491 if (index > 0) {
491 final String _indent; 492 addChunk(buffer, 0, index);
492 _JsonStringStringifierPretty( 493 }
493 StringSink sink, Function toEncodable, this._indent) 494 buffer = null;
494 : super(sink, toEncodable); 495 index = 0;
495 void writeIndentation(int count) { 496 }
496 for (int i = 0; i < count; i++) writeString(_indent); 497 void writeNumber(num number) {
497 } 498 writeAsciiString(number.toString());
498 } 499 }
499 class _JsonUtf8Stringifier extends _JsonStringifier { 500 void writeAsciiString(String string) {
500 final int bufferSize; 501 for (int i = 0;
501 final Function addChunk; 502 i < string.length;
502 Uint8List buffer; 503 i++) {
503 int index = 0; 504 int char = string.codeUnitAt(i);
504 _JsonUtf8Stringifier(toEncodable, int bufferSize, this.addChunk) 505 assert (char <= 0x7f); writeByte(char);
505 : super(DDC$RT.cast(toEncodable, dynamic, __t24, "CastGeneral", 506 }
506 """line 893, column 15 of dart:convert/json.dart: """, 507 }
507 toEncodable is __t24, false)), 508 void writeString(String string) {
508 this.bufferSize = bufferSize, 509 writeStringSlice(string, 0, string.length);
509 buffer = new Uint8List(bufferSize); 510 }
510 static void stringify(Object object, List<int> indent, 511 void writeStringSlice(String string, int start, int end) {
511 toEncodableFunction(Object o), int bufferSize, 512 for (int i = start;
512 void addChunk(Uint8List chunk, int start, int end)) { 513 i < end;
513 _JsonUtf8Stringifier stringifier; 514 i++) {
514 if (indent != null) { 515 int char = string.codeUnitAt(i);
515 stringifier = new _JsonUtf8StringifierPretty( 516 if (char <= 0x7f) {
516 toEncodableFunction, indent, bufferSize, addChunk); 517 writeByte(char);
517 } else { 518 }
518 stringifier = 519 else {
519 new _JsonUtf8Stringifier(toEncodableFunction, bufferSize, addChunk); 520 if ((char & 0xFC00) == 0xD800 && i + 1 < end) {
520 } 521 int nextChar = string.codeUnitAt(i + 1);
521 stringifier.writeObject(object); 522 if ((nextChar & 0xFC00) == 0xDC00) {
522 stringifier.flush(); 523 char = 0x10000 + ((char & 0x3ff) << 10) + (nextChar & 0x3ff);
523 } 524 writeFourByteCharCode(char);
524 void flush() { 525 i++;
525 if (index > 0) { 526 continue;
526 addChunk(buffer, 0, index); 527 }
527 } 528 }
528 buffer = null; 529 writeMultiByteCharCode(char);
529 index = 0; 530 }
530 } 531 }
531 void writeNumber(num number) { 532 }
532 writeAsciiString(number.toString()); 533 void writeCharCode(int charCode) {
533 } 534 if (charCode <= 0x7f) {
534 void writeAsciiString(String string) { 535 writeByte(charCode);
535 for (int i = 0; i < string.length; i++) { 536 return;}
536 int char = string.codeUnitAt(i); 537 writeMultiByteCharCode(charCode);
537 assert(char <= 0x7f); 538 }
538 writeByte(char); 539 void writeMultiByteCharCode(int charCode) {
539 } 540 if (charCode <= 0x7ff) {
540 } 541 writeByte(0xC0 | (charCode >> 6));
541 void writeString(String string) { 542 writeByte(0x80 | (charCode & 0x3f));
542 writeStringSlice(string, 0, string.length); 543 return;}
543 } 544 if (charCode <= 0xffff) {
544 void writeStringSlice(String string, int start, int end) { 545 writeByte(0xE0 | (charCode >> 12));
545 for (int i = start; i < end; i++) { 546 writeByte(0x80 | ((charCode >> 6) & 0x3f));
546 int char = string.codeUnitAt(i); 547 writeByte(0x80 | (charCode & 0x3f));
547 if (char <= 0x7f) { 548 return;}
548 writeByte(char); 549 writeFourByteCharCode(charCode);
549 } else { 550 }
550 if ((char & 0xFC00) == 0xD800 && i + 1 < end) { 551 void writeFourByteCharCode(int charCode) {
551 int nextChar = string.codeUnitAt(i + 1); 552 assert (charCode <= 0x10ffff); writeByte(0xF0 | (charCode >> 18));
552 if ((nextChar & 0xFC00) == 0xDC00) { 553 writeByte(0x80 | ((charCode >> 12) & 0x3f));
553 char = 0x10000 + ((char & 0x3ff) << 10) + (nextChar & 0x3ff); 554 writeByte(0x80 | ((charCode >> 6) & 0x3f));
554 writeFourByteCharCode(char); 555 writeByte(0x80 | (charCode & 0x3f));
555 i++; 556 }
556 continue; 557 void writeByte(int byte) {
557 } 558 assert (byte <= 0xff); if (index == buffer.length) {
558 } 559 addChunk(buffer, 0, index);
559 writeMultiByteCharCode(char); 560 buffer = new Uint8List(bufferSize);
560 } 561 index = 0;
561 } 562 }
562 } 563 buffer[index++] = byte;
563 void writeCharCode(int charCode) { 564 }
564 if (charCode <= 0x7f) { 565 }
565 writeByte(charCode); 566 class _JsonUtf8StringifierPretty extends _JsonUtf8Stringifier with _JsonPrettyP rintMixin {final List<int> indent;
566 return; 567 _JsonUtf8StringifierPretty(toEncodableFunction, this.indent, bufferSize, addChu nk) : super(toEncodableFunction, DDC$RT.cast(bufferSize, dynamic, int, "CastGene ral", """line 1031, column 36 of dart:convert/json.dart: """, bufferSize is int, true), DDC$RT.cast(addChunk, dynamic, Function, "CastGeneral", """line 1031, co lumn 48 of dart:convert/json.dart: """, addChunk is Function, true));
567 } 568 void writeIndentation(int count) {
568 writeMultiByteCharCode(charCode); 569 List<int> indent = this.indent;
569 } 570 int indentLength = indent.length;
570 void writeMultiByteCharCode(int charCode) { 571 if (indentLength == 1) {
571 if (charCode <= 0x7ff) { 572 int char = indent[0];
572 writeByte(0xC0 | (charCode >> 6)); 573 while (count > 0) {
573 writeByte(0x80 | (charCode & 0x3f)); 574 writeByte(char);
574 return; 575 count -= 1;
575 } 576 }
576 if (charCode <= 0xffff) { 577 return;}
577 writeByte(0xE0 | (charCode >> 12)); 578 while (count > 0) {
578 writeByte(0x80 | ((charCode >> 6) & 0x3f)); 579 count--;
579 writeByte(0x80 | (charCode & 0x3f)); 580 int end = index + indentLength;
580 return; 581 if (end <= buffer.length) {
581 } 582 buffer.setRange(index, end, indent);
582 writeFourByteCharCode(charCode); 583 index = end;
583 } 584 }
584 void writeFourByteCharCode(int charCode) { 585 else {
585 assert(charCode <= 0x10ffff); 586 for (int i = 0;
586 writeByte(0xF0 | (charCode >> 18)); 587 i < indentLength;
587 writeByte(0x80 | ((charCode >> 12) & 0x3f)); 588 i++) {
588 writeByte(0x80 | ((charCode >> 6) & 0x3f)); 589 writeByte(indent[i]);
589 writeByte(0x80 | (charCode & 0x3f)); 590 }
590 } 591 }
591 void writeByte(int byte) { 592 }
592 assert(byte <= 0xff); 593 }
593 if (index == buffer.length) { 594 }
594 addChunk(buffer, 0, index); 595 typedef dynamic __t7(dynamic __u8);
595 buffer = new Uint8List(bufferSize); 596 typedef dynamic __t11(Object __u12);
596 index = 0; 597 typedef void __t17(dynamic __u18, dynamic __u19);
597 } 598 typedef dynamic __t20(String __u21, Object __u22);
598 buffer[index++] = byte; 599 typedef Object __t24(Object __u25);
599 }
600 }
601 class _JsonUtf8StringifierPretty extends _JsonUtf8Stringifier
602 with _JsonPrettyPrintMixin {
603 final List<int> indent;
604 _JsonUtf8StringifierPretty(
605 toEncodableFunction, this.indent, bufferSize, addChunk)
606 : super(toEncodableFunction, DDC$RT.cast(bufferSize, dynamic, int,
607 "CastGeneral", """line 1031, column 36 of dart:convert/json.dart: """,
608 bufferSize is int, true), DDC$RT.cast(addChunk, dynamic, Function,
609 "CastGeneral", """line 1031, column 48 of dart:convert/json.dart: """,
610 addChunk is Function, true));
611 void writeIndentation(int count) {
612 List<int> indent = this.indent;
613 int indentLength = indent.length;
614 if (indentLength == 1) {
615 int char = indent[0];
616 while (count > 0) {
617 writeByte(char);
618 count -= 1;
619 }
620 return;
621 }
622 while (count > 0) {
623 count--;
624 int end = index + indentLength;
625 if (end <= buffer.length) {
626 buffer.setRange(index, end, indent);
627 index = end;
628 } else {
629 for (int i = 0; i < indentLength; i++) {
630 writeByte(indent[i]);
631 }
632 }
633 }
634 }
635 }
636 typedef dynamic __t7(dynamic __u8);
637 typedef dynamic __t11(Object __u12);
638 typedef void __t17(dynamic __u18, dynamic __u19);
639 typedef dynamic __t20(String __u21, Object __u22);
640 typedef Object __t24(Object __u25);
OLDNEW
« test/dart_codegen/expect/_internal/iterable.dart ('K') | « test/dart_codegen/expect/convert/html_escape.dart ('k') | test/dart_codegen/expect/convert/latin1.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698