OLD | NEW |
| (Empty) |
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | |
2 // for details. All rights reserved. Use of this source code is governed by a | |
3 // BSD-style license that can be found in the LICENSE file. | |
4 // | |
5 // This file has been automatically generated. Please do not edit it manually. | |
6 // To regenerate the file, use the script | |
7 // "pkg/analysis_server/tool/spec/generate_files". | |
8 | |
9 part of protocol; | |
10 /** | |
11 * server.getVersion params | |
12 */ | |
13 class ServerGetVersionParams { | |
14 Request toRequest(String id) { | |
15 return new Request(id, "server.getVersion", null); | |
16 } | |
17 | |
18 @override | |
19 bool operator==(other) { | |
20 if (other is ServerGetVersionParams) { | |
21 return true; | |
22 } | |
23 return false; | |
24 } | |
25 | |
26 @override | |
27 int get hashCode { | |
28 return 55877452; | |
29 } | |
30 } | |
31 | |
32 /** | |
33 * server.getVersion result | |
34 * | |
35 * { | |
36 * "version": String | |
37 * } | |
38 */ | |
39 class ServerGetVersionResult implements HasToJson { | |
40 String _version; | |
41 | |
42 /** | |
43 * The version number of the analysis server. | |
44 */ | |
45 String get version => _version; | |
46 | |
47 /** | |
48 * The version number of the analysis server. | |
49 */ | |
50 void set version(String value) { | |
51 assert(value != null); | |
52 this._version = value; | |
53 } | |
54 | |
55 ServerGetVersionResult(String version) { | |
56 this.version = version; | |
57 } | |
58 | |
59 factory ServerGetVersionResult.fromJson(JsonDecoder jsonDecoder, String jsonPa
th, Object json) { | |
60 if (json == null) { | |
61 json = {}; | |
62 } | |
63 if (json is Map) { | |
64 String version; | |
65 if (json.containsKey("version")) { | |
66 version = jsonDecoder._decodeString(jsonPath + ".version", json["version
"]); | |
67 } else { | |
68 throw jsonDecoder.missingKey(jsonPath, "version"); | |
69 } | |
70 return new ServerGetVersionResult(version); | |
71 } else { | |
72 throw jsonDecoder.mismatch(jsonPath, "server.getVersion result", json); | |
73 } | |
74 } | |
75 | |
76 factory ServerGetVersionResult.fromResponse(Response response) { | |
77 return new ServerGetVersionResult.fromJson( | |
78 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
79 } | |
80 | |
81 Map<String, dynamic> toJson() { | |
82 Map<String, dynamic> result = {}; | |
83 result["version"] = version; | |
84 return result; | |
85 } | |
86 | |
87 Response toResponse(String id) { | |
88 return new Response(id, result: toJson()); | |
89 } | |
90 | |
91 @override | |
92 String toString() => JSON.encode(toJson()); | |
93 | |
94 @override | |
95 bool operator==(other) { | |
96 if (other is ServerGetVersionResult) { | |
97 return version == other.version; | |
98 } | |
99 return false; | |
100 } | |
101 | |
102 @override | |
103 int get hashCode { | |
104 int hash = 0; | |
105 hash = _JenkinsSmiHash.combine(hash, version.hashCode); | |
106 return _JenkinsSmiHash.finish(hash); | |
107 } | |
108 } | |
109 /** | |
110 * server.shutdown params | |
111 */ | |
112 class ServerShutdownParams { | |
113 Request toRequest(String id) { | |
114 return new Request(id, "server.shutdown", null); | |
115 } | |
116 | |
117 @override | |
118 bool operator==(other) { | |
119 if (other is ServerShutdownParams) { | |
120 return true; | |
121 } | |
122 return false; | |
123 } | |
124 | |
125 @override | |
126 int get hashCode { | |
127 return 366630911; | |
128 } | |
129 } | |
130 /** | |
131 * server.shutdown result | |
132 */ | |
133 class ServerShutdownResult { | |
134 Response toResponse(String id) { | |
135 return new Response(id, result: null); | |
136 } | |
137 | |
138 @override | |
139 bool operator==(other) { | |
140 if (other is ServerShutdownResult) { | |
141 return true; | |
142 } | |
143 return false; | |
144 } | |
145 | |
146 @override | |
147 int get hashCode { | |
148 return 193626532; | |
149 } | |
150 } | |
151 | |
152 /** | |
153 * server.setSubscriptions params | |
154 * | |
155 * { | |
156 * "subscriptions": List<ServerService> | |
157 * } | |
158 */ | |
159 class ServerSetSubscriptionsParams implements HasToJson { | |
160 List<ServerService> _subscriptions; | |
161 | |
162 /** | |
163 * A list of the services being subscribed to. | |
164 */ | |
165 List<ServerService> get subscriptions => _subscriptions; | |
166 | |
167 /** | |
168 * A list of the services being subscribed to. | |
169 */ | |
170 void set subscriptions(List<ServerService> value) { | |
171 assert(value != null); | |
172 this._subscriptions = value; | |
173 } | |
174 | |
175 ServerSetSubscriptionsParams(List<ServerService> subscriptions) { | |
176 this.subscriptions = subscriptions; | |
177 } | |
178 | |
179 factory ServerSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String
jsonPath, Object json) { | |
180 if (json == null) { | |
181 json = {}; | |
182 } | |
183 if (json is Map) { | |
184 List<ServerService> subscriptions; | |
185 if (json.containsKey("subscriptions")) { | |
186 subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", jso
n["subscriptions"], (String jsonPath, Object json) => new ServerService.fromJson
(jsonDecoder, jsonPath, json)); | |
187 } else { | |
188 throw jsonDecoder.missingKey(jsonPath, "subscriptions"); | |
189 } | |
190 return new ServerSetSubscriptionsParams(subscriptions); | |
191 } else { | |
192 throw jsonDecoder.mismatch(jsonPath, "server.setSubscriptions params", jso
n); | |
193 } | |
194 } | |
195 | |
196 factory ServerSetSubscriptionsParams.fromRequest(Request request) { | |
197 return new ServerSetSubscriptionsParams.fromJson( | |
198 new RequestDecoder(request), "params", request._params); | |
199 } | |
200 | |
201 Map<String, dynamic> toJson() { | |
202 Map<String, dynamic> result = {}; | |
203 result["subscriptions"] = subscriptions.map((ServerService value) => value.t
oJson()).toList(); | |
204 return result; | |
205 } | |
206 | |
207 Request toRequest(String id) { | |
208 return new Request(id, "server.setSubscriptions", toJson()); | |
209 } | |
210 | |
211 @override | |
212 String toString() => JSON.encode(toJson()); | |
213 | |
214 @override | |
215 bool operator==(other) { | |
216 if (other is ServerSetSubscriptionsParams) { | |
217 return _listEqual(subscriptions, other.subscriptions, (ServerService a, Se
rverService b) => a == b); | |
218 } | |
219 return false; | |
220 } | |
221 | |
222 @override | |
223 int get hashCode { | |
224 int hash = 0; | |
225 hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode); | |
226 return _JenkinsSmiHash.finish(hash); | |
227 } | |
228 } | |
229 /** | |
230 * server.setSubscriptions result | |
231 */ | |
232 class ServerSetSubscriptionsResult { | |
233 Response toResponse(String id) { | |
234 return new Response(id, result: null); | |
235 } | |
236 | |
237 @override | |
238 bool operator==(other) { | |
239 if (other is ServerSetSubscriptionsResult) { | |
240 return true; | |
241 } | |
242 return false; | |
243 } | |
244 | |
245 @override | |
246 int get hashCode { | |
247 return 748820900; | |
248 } | |
249 } | |
250 | |
251 /** | |
252 * server.connected params | |
253 * | |
254 * { | |
255 * "version": String | |
256 * } | |
257 */ | |
258 class ServerConnectedParams implements HasToJson { | |
259 String _version; | |
260 | |
261 /** | |
262 * The version number of the analysis server. | |
263 */ | |
264 String get version => _version; | |
265 | |
266 /** | |
267 * The version number of the analysis server. | |
268 */ | |
269 void set version(String value) { | |
270 assert(value != null); | |
271 this._version = value; | |
272 } | |
273 | |
274 ServerConnectedParams(String version) { | |
275 this.version = version; | |
276 } | |
277 | |
278 factory ServerConnectedParams.fromJson(JsonDecoder jsonDecoder, String jsonPat
h, Object json) { | |
279 if (json == null) { | |
280 json = {}; | |
281 } | |
282 if (json is Map) { | |
283 String version; | |
284 if (json.containsKey("version")) { | |
285 version = jsonDecoder._decodeString(jsonPath + ".version", json["version
"]); | |
286 } else { | |
287 throw jsonDecoder.missingKey(jsonPath, "version"); | |
288 } | |
289 return new ServerConnectedParams(version); | |
290 } else { | |
291 throw jsonDecoder.mismatch(jsonPath, "server.connected params", json); | |
292 } | |
293 } | |
294 | |
295 factory ServerConnectedParams.fromNotification(Notification notification) { | |
296 return new ServerConnectedParams.fromJson( | |
297 new ResponseDecoder(null), "params", notification._params); | |
298 } | |
299 | |
300 Map<String, dynamic> toJson() { | |
301 Map<String, dynamic> result = {}; | |
302 result["version"] = version; | |
303 return result; | |
304 } | |
305 | |
306 Notification toNotification() { | |
307 return new Notification("server.connected", toJson()); | |
308 } | |
309 | |
310 @override | |
311 String toString() => JSON.encode(toJson()); | |
312 | |
313 @override | |
314 bool operator==(other) { | |
315 if (other is ServerConnectedParams) { | |
316 return version == other.version; | |
317 } | |
318 return false; | |
319 } | |
320 | |
321 @override | |
322 int get hashCode { | |
323 int hash = 0; | |
324 hash = _JenkinsSmiHash.combine(hash, version.hashCode); | |
325 return _JenkinsSmiHash.finish(hash); | |
326 } | |
327 } | |
328 | |
329 /** | |
330 * server.error params | |
331 * | |
332 * { | |
333 * "isFatal": bool | |
334 * "message": String | |
335 * "stackTrace": String | |
336 * } | |
337 */ | |
338 class ServerErrorParams implements HasToJson { | |
339 bool _isFatal; | |
340 | |
341 String _message; | |
342 | |
343 String _stackTrace; | |
344 | |
345 /** | |
346 * True if the error is a fatal error, meaning that the server will shutdown | |
347 * automatically after sending this notification. | |
348 */ | |
349 bool get isFatal => _isFatal; | |
350 | |
351 /** | |
352 * True if the error is a fatal error, meaning that the server will shutdown | |
353 * automatically after sending this notification. | |
354 */ | |
355 void set isFatal(bool value) { | |
356 assert(value != null); | |
357 this._isFatal = value; | |
358 } | |
359 | |
360 /** | |
361 * The error message indicating what kind of error was encountered. | |
362 */ | |
363 String get message => _message; | |
364 | |
365 /** | |
366 * The error message indicating what kind of error was encountered. | |
367 */ | |
368 void set message(String value) { | |
369 assert(value != null); | |
370 this._message = value; | |
371 } | |
372 | |
373 /** | |
374 * The stack trace associated with the generation of the error, used for | |
375 * debugging the server. | |
376 */ | |
377 String get stackTrace => _stackTrace; | |
378 | |
379 /** | |
380 * The stack trace associated with the generation of the error, used for | |
381 * debugging the server. | |
382 */ | |
383 void set stackTrace(String value) { | |
384 assert(value != null); | |
385 this._stackTrace = value; | |
386 } | |
387 | |
388 ServerErrorParams(bool isFatal, String message, String stackTrace) { | |
389 this.isFatal = isFatal; | |
390 this.message = message; | |
391 this.stackTrace = stackTrace; | |
392 } | |
393 | |
394 factory ServerErrorParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, O
bject json) { | |
395 if (json == null) { | |
396 json = {}; | |
397 } | |
398 if (json is Map) { | |
399 bool isFatal; | |
400 if (json.containsKey("isFatal")) { | |
401 isFatal = jsonDecoder._decodeBool(jsonPath + ".isFatal", json["isFatal"]
); | |
402 } else { | |
403 throw jsonDecoder.missingKey(jsonPath, "isFatal"); | |
404 } | |
405 String message; | |
406 if (json.containsKey("message")) { | |
407 message = jsonDecoder._decodeString(jsonPath + ".message", json["message
"]); | |
408 } else { | |
409 throw jsonDecoder.missingKey(jsonPath, "message"); | |
410 } | |
411 String stackTrace; | |
412 if (json.containsKey("stackTrace")) { | |
413 stackTrace = jsonDecoder._decodeString(jsonPath + ".stackTrace", json["s
tackTrace"]); | |
414 } else { | |
415 throw jsonDecoder.missingKey(jsonPath, "stackTrace"); | |
416 } | |
417 return new ServerErrorParams(isFatal, message, stackTrace); | |
418 } else { | |
419 throw jsonDecoder.mismatch(jsonPath, "server.error params", json); | |
420 } | |
421 } | |
422 | |
423 factory ServerErrorParams.fromNotification(Notification notification) { | |
424 return new ServerErrorParams.fromJson( | |
425 new ResponseDecoder(null), "params", notification._params); | |
426 } | |
427 | |
428 Map<String, dynamic> toJson() { | |
429 Map<String, dynamic> result = {}; | |
430 result["isFatal"] = isFatal; | |
431 result["message"] = message; | |
432 result["stackTrace"] = stackTrace; | |
433 return result; | |
434 } | |
435 | |
436 Notification toNotification() { | |
437 return new Notification("server.error", toJson()); | |
438 } | |
439 | |
440 @override | |
441 String toString() => JSON.encode(toJson()); | |
442 | |
443 @override | |
444 bool operator==(other) { | |
445 if (other is ServerErrorParams) { | |
446 return isFatal == other.isFatal && | |
447 message == other.message && | |
448 stackTrace == other.stackTrace; | |
449 } | |
450 return false; | |
451 } | |
452 | |
453 @override | |
454 int get hashCode { | |
455 int hash = 0; | |
456 hash = _JenkinsSmiHash.combine(hash, isFatal.hashCode); | |
457 hash = _JenkinsSmiHash.combine(hash, message.hashCode); | |
458 hash = _JenkinsSmiHash.combine(hash, stackTrace.hashCode); | |
459 return _JenkinsSmiHash.finish(hash); | |
460 } | |
461 } | |
462 | |
463 /** | |
464 * server.status params | |
465 * | |
466 * { | |
467 * "analysis": optional AnalysisStatus | |
468 * "pub": optional PubStatus | |
469 * } | |
470 */ | |
471 class ServerStatusParams implements HasToJson { | |
472 AnalysisStatus _analysis; | |
473 | |
474 PubStatus _pub; | |
475 | |
476 /** | |
477 * The current status of analysis, including whether analysis is being | |
478 * performed and if so what is being analyzed. | |
479 */ | |
480 AnalysisStatus get analysis => _analysis; | |
481 | |
482 /** | |
483 * The current status of analysis, including whether analysis is being | |
484 * performed and if so what is being analyzed. | |
485 */ | |
486 void set analysis(AnalysisStatus value) { | |
487 this._analysis = value; | |
488 } | |
489 | |
490 /** | |
491 * The current status of pub execution, indicating whether we are currently | |
492 * running pub. | |
493 */ | |
494 PubStatus get pub => _pub; | |
495 | |
496 /** | |
497 * The current status of pub execution, indicating whether we are currently | |
498 * running pub. | |
499 */ | |
500 void set pub(PubStatus value) { | |
501 this._pub = value; | |
502 } | |
503 | |
504 ServerStatusParams({AnalysisStatus analysis, PubStatus pub}) { | |
505 this.analysis = analysis; | |
506 this.pub = pub; | |
507 } | |
508 | |
509 factory ServerStatusParams.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json) { | |
510 if (json == null) { | |
511 json = {}; | |
512 } | |
513 if (json is Map) { | |
514 AnalysisStatus analysis; | |
515 if (json.containsKey("analysis")) { | |
516 analysis = new AnalysisStatus.fromJson(jsonDecoder, jsonPath + ".analysi
s", json["analysis"]); | |
517 } | |
518 PubStatus pub; | |
519 if (json.containsKey("pub")) { | |
520 pub = new PubStatus.fromJson(jsonDecoder, jsonPath + ".pub", json["pub"]
); | |
521 } | |
522 return new ServerStatusParams(analysis: analysis, pub: pub); | |
523 } else { | |
524 throw jsonDecoder.mismatch(jsonPath, "server.status params", json); | |
525 } | |
526 } | |
527 | |
528 factory ServerStatusParams.fromNotification(Notification notification) { | |
529 return new ServerStatusParams.fromJson( | |
530 new ResponseDecoder(null), "params", notification._params); | |
531 } | |
532 | |
533 Map<String, dynamic> toJson() { | |
534 Map<String, dynamic> result = {}; | |
535 if (analysis != null) { | |
536 result["analysis"] = analysis.toJson(); | |
537 } | |
538 if (pub != null) { | |
539 result["pub"] = pub.toJson(); | |
540 } | |
541 return result; | |
542 } | |
543 | |
544 Notification toNotification() { | |
545 return new Notification("server.status", toJson()); | |
546 } | |
547 | |
548 @override | |
549 String toString() => JSON.encode(toJson()); | |
550 | |
551 @override | |
552 bool operator==(other) { | |
553 if (other is ServerStatusParams) { | |
554 return analysis == other.analysis && | |
555 pub == other.pub; | |
556 } | |
557 return false; | |
558 } | |
559 | |
560 @override | |
561 int get hashCode { | |
562 int hash = 0; | |
563 hash = _JenkinsSmiHash.combine(hash, analysis.hashCode); | |
564 hash = _JenkinsSmiHash.combine(hash, pub.hashCode); | |
565 return _JenkinsSmiHash.finish(hash); | |
566 } | |
567 } | |
568 | |
569 /** | |
570 * analysis.getErrors params | |
571 * | |
572 * { | |
573 * "file": FilePath | |
574 * } | |
575 */ | |
576 class AnalysisGetErrorsParams implements HasToJson { | |
577 String _file; | |
578 | |
579 /** | |
580 * The file for which errors are being requested. | |
581 */ | |
582 String get file => _file; | |
583 | |
584 /** | |
585 * The file for which errors are being requested. | |
586 */ | |
587 void set file(String value) { | |
588 assert(value != null); | |
589 this._file = value; | |
590 } | |
591 | |
592 AnalysisGetErrorsParams(String file) { | |
593 this.file = file; | |
594 } | |
595 | |
596 factory AnalysisGetErrorsParams.fromJson(JsonDecoder jsonDecoder, String jsonP
ath, Object json) { | |
597 if (json == null) { | |
598 json = {}; | |
599 } | |
600 if (json is Map) { | |
601 String file; | |
602 if (json.containsKey("file")) { | |
603 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
604 } else { | |
605 throw jsonDecoder.missingKey(jsonPath, "file"); | |
606 } | |
607 return new AnalysisGetErrorsParams(file); | |
608 } else { | |
609 throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors params", json); | |
610 } | |
611 } | |
612 | |
613 factory AnalysisGetErrorsParams.fromRequest(Request request) { | |
614 return new AnalysisGetErrorsParams.fromJson( | |
615 new RequestDecoder(request), "params", request._params); | |
616 } | |
617 | |
618 Map<String, dynamic> toJson() { | |
619 Map<String, dynamic> result = {}; | |
620 result["file"] = file; | |
621 return result; | |
622 } | |
623 | |
624 Request toRequest(String id) { | |
625 return new Request(id, "analysis.getErrors", toJson()); | |
626 } | |
627 | |
628 @override | |
629 String toString() => JSON.encode(toJson()); | |
630 | |
631 @override | |
632 bool operator==(other) { | |
633 if (other is AnalysisGetErrorsParams) { | |
634 return file == other.file; | |
635 } | |
636 return false; | |
637 } | |
638 | |
639 @override | |
640 int get hashCode { | |
641 int hash = 0; | |
642 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
643 return _JenkinsSmiHash.finish(hash); | |
644 } | |
645 } | |
646 | |
647 /** | |
648 * analysis.getErrors result | |
649 * | |
650 * { | |
651 * "errors": List<AnalysisError> | |
652 * } | |
653 */ | |
654 class AnalysisGetErrorsResult implements HasToJson { | |
655 List<AnalysisError> _errors; | |
656 | |
657 /** | |
658 * The errors associated with the file. | |
659 */ | |
660 List<AnalysisError> get errors => _errors; | |
661 | |
662 /** | |
663 * The errors associated with the file. | |
664 */ | |
665 void set errors(List<AnalysisError> value) { | |
666 assert(value != null); | |
667 this._errors = value; | |
668 } | |
669 | |
670 AnalysisGetErrorsResult(List<AnalysisError> errors) { | |
671 this.errors = errors; | |
672 } | |
673 | |
674 factory AnalysisGetErrorsResult.fromJson(JsonDecoder jsonDecoder, String jsonP
ath, Object json) { | |
675 if (json == null) { | |
676 json = {}; | |
677 } | |
678 if (json is Map) { | |
679 List<AnalysisError> errors; | |
680 if (json.containsKey("errors")) { | |
681 errors = jsonDecoder._decodeList(jsonPath + ".errors", json["errors"], (
String jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPat
h, json)); | |
682 } else { | |
683 throw jsonDecoder.missingKey(jsonPath, "errors"); | |
684 } | |
685 return new AnalysisGetErrorsResult(errors); | |
686 } else { | |
687 throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors result", json); | |
688 } | |
689 } | |
690 | |
691 factory AnalysisGetErrorsResult.fromResponse(Response response) { | |
692 return new AnalysisGetErrorsResult.fromJson( | |
693 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
694 } | |
695 | |
696 Map<String, dynamic> toJson() { | |
697 Map<String, dynamic> result = {}; | |
698 result["errors"] = errors.map((AnalysisError value) => value.toJson()).toLis
t(); | |
699 return result; | |
700 } | |
701 | |
702 Response toResponse(String id) { | |
703 return new Response(id, result: toJson()); | |
704 } | |
705 | |
706 @override | |
707 String toString() => JSON.encode(toJson()); | |
708 | |
709 @override | |
710 bool operator==(other) { | |
711 if (other is AnalysisGetErrorsResult) { | |
712 return _listEqual(errors, other.errors, (AnalysisError a, AnalysisError b)
=> a == b); | |
713 } | |
714 return false; | |
715 } | |
716 | |
717 @override | |
718 int get hashCode { | |
719 int hash = 0; | |
720 hash = _JenkinsSmiHash.combine(hash, errors.hashCode); | |
721 return _JenkinsSmiHash.finish(hash); | |
722 } | |
723 } | |
724 | |
725 /** | |
726 * analysis.getHover params | |
727 * | |
728 * { | |
729 * "file": FilePath | |
730 * "offset": int | |
731 * } | |
732 */ | |
733 class AnalysisGetHoverParams implements HasToJson { | |
734 String _file; | |
735 | |
736 int _offset; | |
737 | |
738 /** | |
739 * The file in which hover information is being requested. | |
740 */ | |
741 String get file => _file; | |
742 | |
743 /** | |
744 * The file in which hover information is being requested. | |
745 */ | |
746 void set file(String value) { | |
747 assert(value != null); | |
748 this._file = value; | |
749 } | |
750 | |
751 /** | |
752 * The offset for which hover information is being requested. | |
753 */ | |
754 int get offset => _offset; | |
755 | |
756 /** | |
757 * The offset for which hover information is being requested. | |
758 */ | |
759 void set offset(int value) { | |
760 assert(value != null); | |
761 this._offset = value; | |
762 } | |
763 | |
764 AnalysisGetHoverParams(String file, int offset) { | |
765 this.file = file; | |
766 this.offset = offset; | |
767 } | |
768 | |
769 factory AnalysisGetHoverParams.fromJson(JsonDecoder jsonDecoder, String jsonPa
th, Object json) { | |
770 if (json == null) { | |
771 json = {}; | |
772 } | |
773 if (json is Map) { | |
774 String file; | |
775 if (json.containsKey("file")) { | |
776 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
777 } else { | |
778 throw jsonDecoder.missingKey(jsonPath, "file"); | |
779 } | |
780 int offset; | |
781 if (json.containsKey("offset")) { | |
782 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
783 } else { | |
784 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
785 } | |
786 return new AnalysisGetHoverParams(file, offset); | |
787 } else { | |
788 throw jsonDecoder.mismatch(jsonPath, "analysis.getHover params", json); | |
789 } | |
790 } | |
791 | |
792 factory AnalysisGetHoverParams.fromRequest(Request request) { | |
793 return new AnalysisGetHoverParams.fromJson( | |
794 new RequestDecoder(request), "params", request._params); | |
795 } | |
796 | |
797 Map<String, dynamic> toJson() { | |
798 Map<String, dynamic> result = {}; | |
799 result["file"] = file; | |
800 result["offset"] = offset; | |
801 return result; | |
802 } | |
803 | |
804 Request toRequest(String id) { | |
805 return new Request(id, "analysis.getHover", toJson()); | |
806 } | |
807 | |
808 @override | |
809 String toString() => JSON.encode(toJson()); | |
810 | |
811 @override | |
812 bool operator==(other) { | |
813 if (other is AnalysisGetHoverParams) { | |
814 return file == other.file && | |
815 offset == other.offset; | |
816 } | |
817 return false; | |
818 } | |
819 | |
820 @override | |
821 int get hashCode { | |
822 int hash = 0; | |
823 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
824 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
825 return _JenkinsSmiHash.finish(hash); | |
826 } | |
827 } | |
828 | |
829 /** | |
830 * analysis.getHover result | |
831 * | |
832 * { | |
833 * "hovers": List<HoverInformation> | |
834 * } | |
835 */ | |
836 class AnalysisGetHoverResult implements HasToJson { | |
837 List<HoverInformation> _hovers; | |
838 | |
839 /** | |
840 * The hover information associated with the location. The list will be empty | |
841 * if no information could be determined for the location. The list can | |
842 * contain multiple items if the file is being analyzed in multiple contexts | |
843 * in conflicting ways (such as a part that is included in multiple | |
844 * libraries). | |
845 */ | |
846 List<HoverInformation> get hovers => _hovers; | |
847 | |
848 /** | |
849 * The hover information associated with the location. The list will be empty | |
850 * if no information could be determined for the location. The list can | |
851 * contain multiple items if the file is being analyzed in multiple contexts | |
852 * in conflicting ways (such as a part that is included in multiple | |
853 * libraries). | |
854 */ | |
855 void set hovers(List<HoverInformation> value) { | |
856 assert(value != null); | |
857 this._hovers = value; | |
858 } | |
859 | |
860 AnalysisGetHoverResult(List<HoverInformation> hovers) { | |
861 this.hovers = hovers; | |
862 } | |
863 | |
864 factory AnalysisGetHoverResult.fromJson(JsonDecoder jsonDecoder, String jsonPa
th, Object json) { | |
865 if (json == null) { | |
866 json = {}; | |
867 } | |
868 if (json is Map) { | |
869 List<HoverInformation> hovers; | |
870 if (json.containsKey("hovers")) { | |
871 hovers = jsonDecoder._decodeList(jsonPath + ".hovers", json["hovers"], (
String jsonPath, Object json) => new HoverInformation.fromJson(jsonDecoder, json
Path, json)); | |
872 } else { | |
873 throw jsonDecoder.missingKey(jsonPath, "hovers"); | |
874 } | |
875 return new AnalysisGetHoverResult(hovers); | |
876 } else { | |
877 throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result", json); | |
878 } | |
879 } | |
880 | |
881 factory AnalysisGetHoverResult.fromResponse(Response response) { | |
882 return new AnalysisGetHoverResult.fromJson( | |
883 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
884 } | |
885 | |
886 Map<String, dynamic> toJson() { | |
887 Map<String, dynamic> result = {}; | |
888 result["hovers"] = hovers.map((HoverInformation value) => value.toJson()).to
List(); | |
889 return result; | |
890 } | |
891 | |
892 Response toResponse(String id) { | |
893 return new Response(id, result: toJson()); | |
894 } | |
895 | |
896 @override | |
897 String toString() => JSON.encode(toJson()); | |
898 | |
899 @override | |
900 bool operator==(other) { | |
901 if (other is AnalysisGetHoverResult) { | |
902 return _listEqual(hovers, other.hovers, (HoverInformation a, HoverInformat
ion b) => a == b); | |
903 } | |
904 return false; | |
905 } | |
906 | |
907 @override | |
908 int get hashCode { | |
909 int hash = 0; | |
910 hash = _JenkinsSmiHash.combine(hash, hovers.hashCode); | |
911 return _JenkinsSmiHash.finish(hash); | |
912 } | |
913 } | |
914 /** | |
915 * analysis.getLibraryDependencies params | |
916 */ | |
917 class AnalysisGetLibraryDependenciesParams { | |
918 Request toRequest(String id) { | |
919 return new Request(id, "analysis.getLibraryDependencies", null); | |
920 } | |
921 | |
922 @override | |
923 bool operator==(other) { | |
924 if (other is AnalysisGetLibraryDependenciesParams) { | |
925 return true; | |
926 } | |
927 return false; | |
928 } | |
929 | |
930 @override | |
931 int get hashCode { | |
932 return 246577680; | |
933 } | |
934 } | |
935 | |
936 /** | |
937 * analysis.getLibraryDependencies result | |
938 * | |
939 * { | |
940 * "libraries": List<FilePath> | |
941 * "packageMap": Map<String, Map<String, List<FilePath>>> | |
942 * } | |
943 */ | |
944 class AnalysisGetLibraryDependenciesResult implements HasToJson { | |
945 List<String> _libraries; | |
946 | |
947 Map<String, Map<String, List<String>>> _packageMap; | |
948 | |
949 /** | |
950 * A list of the paths of library elements referenced by files in existing | |
951 * analysis roots. | |
952 */ | |
953 List<String> get libraries => _libraries; | |
954 | |
955 /** | |
956 * A list of the paths of library elements referenced by files in existing | |
957 * analysis roots. | |
958 */ | |
959 void set libraries(List<String> value) { | |
960 assert(value != null); | |
961 this._libraries = value; | |
962 } | |
963 | |
964 /** | |
965 * A mapping from context source roots to package maps which map package | |
966 * names to source directories for use in client-side package URI resolution. | |
967 */ | |
968 Map<String, Map<String, List<String>>> get packageMap => _packageMap; | |
969 | |
970 /** | |
971 * A mapping from context source roots to package maps which map package | |
972 * names to source directories for use in client-side package URI resolution. | |
973 */ | |
974 void set packageMap(Map<String, Map<String, List<String>>> value) { | |
975 assert(value != null); | |
976 this._packageMap = value; | |
977 } | |
978 | |
979 AnalysisGetLibraryDependenciesResult(List<String> libraries, Map<String, Map<S
tring, List<String>>> packageMap) { | |
980 this.libraries = libraries; | |
981 this.packageMap = packageMap; | |
982 } | |
983 | |
984 factory AnalysisGetLibraryDependenciesResult.fromJson(JsonDecoder jsonDecoder,
String jsonPath, Object json) { | |
985 if (json == null) { | |
986 json = {}; | |
987 } | |
988 if (json is Map) { | |
989 List<String> libraries; | |
990 if (json.containsKey("libraries")) { | |
991 libraries = jsonDecoder._decodeList(jsonPath + ".libraries", json["libra
ries"], jsonDecoder._decodeString); | |
992 } else { | |
993 throw jsonDecoder.missingKey(jsonPath, "libraries"); | |
994 } | |
995 Map<String, Map<String, List<String>>> packageMap; | |
996 if (json.containsKey("packageMap")) { | |
997 packageMap = jsonDecoder._decodeMap(jsonPath + ".packageMap", json["pack
ageMap"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeMap
(jsonPath, json, valueDecoder: (String jsonPath, Object json) => jsonDecoder._de
codeList(jsonPath, json, jsonDecoder._decodeString))); | |
998 } else { | |
999 throw jsonDecoder.missingKey(jsonPath, "packageMap"); | |
1000 } | |
1001 return new AnalysisGetLibraryDependenciesResult(libraries, packageMap); | |
1002 } else { | |
1003 throw jsonDecoder.mismatch(jsonPath, "analysis.getLibraryDependencies resu
lt", json); | |
1004 } | |
1005 } | |
1006 | |
1007 factory AnalysisGetLibraryDependenciesResult.fromResponse(Response response) { | |
1008 return new AnalysisGetLibraryDependenciesResult.fromJson( | |
1009 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
1010 } | |
1011 | |
1012 Map<String, dynamic> toJson() { | |
1013 Map<String, dynamic> result = {}; | |
1014 result["libraries"] = libraries; | |
1015 result["packageMap"] = packageMap; | |
1016 return result; | |
1017 } | |
1018 | |
1019 Response toResponse(String id) { | |
1020 return new Response(id, result: toJson()); | |
1021 } | |
1022 | |
1023 @override | |
1024 String toString() => JSON.encode(toJson()); | |
1025 | |
1026 @override | |
1027 bool operator==(other) { | |
1028 if (other is AnalysisGetLibraryDependenciesResult) { | |
1029 return _listEqual(libraries, other.libraries, (String a, String b) => a ==
b) && | |
1030 _mapEqual(packageMap, other.packageMap, (Map<String, List<String>> a,
Map<String, List<String>> b) => _mapEqual(a, b, (List<String> a, List<String> b)
=> _listEqual(a, b, (String a, String b) => a == b))); | |
1031 } | |
1032 return false; | |
1033 } | |
1034 | |
1035 @override | |
1036 int get hashCode { | |
1037 int hash = 0; | |
1038 hash = _JenkinsSmiHash.combine(hash, libraries.hashCode); | |
1039 hash = _JenkinsSmiHash.combine(hash, packageMap.hashCode); | |
1040 return _JenkinsSmiHash.finish(hash); | |
1041 } | |
1042 } | |
1043 | |
1044 /** | |
1045 * analysis.getNavigation params | |
1046 * | |
1047 * { | |
1048 * "file": FilePath | |
1049 * "offset": int | |
1050 * "length": int | |
1051 * } | |
1052 */ | |
1053 class AnalysisGetNavigationParams implements HasToJson { | |
1054 String _file; | |
1055 | |
1056 int _offset; | |
1057 | |
1058 int _length; | |
1059 | |
1060 /** | |
1061 * The file in which navigation information is being requested. | |
1062 */ | |
1063 String get file => _file; | |
1064 | |
1065 /** | |
1066 * The file in which navigation information is being requested. | |
1067 */ | |
1068 void set file(String value) { | |
1069 assert(value != null); | |
1070 this._file = value; | |
1071 } | |
1072 | |
1073 /** | |
1074 * The offset of the region for which navigation information is being | |
1075 * requested. | |
1076 */ | |
1077 int get offset => _offset; | |
1078 | |
1079 /** | |
1080 * The offset of the region for which navigation information is being | |
1081 * requested. | |
1082 */ | |
1083 void set offset(int value) { | |
1084 assert(value != null); | |
1085 this._offset = value; | |
1086 } | |
1087 | |
1088 /** | |
1089 * The length of the region for which navigation information is being | |
1090 * requested. | |
1091 */ | |
1092 int get length => _length; | |
1093 | |
1094 /** | |
1095 * The length of the region for which navigation information is being | |
1096 * requested. | |
1097 */ | |
1098 void set length(int value) { | |
1099 assert(value != null); | |
1100 this._length = value; | |
1101 } | |
1102 | |
1103 AnalysisGetNavigationParams(String file, int offset, int length) { | |
1104 this.file = file; | |
1105 this.offset = offset; | |
1106 this.length = length; | |
1107 } | |
1108 | |
1109 factory AnalysisGetNavigationParams.fromJson(JsonDecoder jsonDecoder, String j
sonPath, Object json) { | |
1110 if (json == null) { | |
1111 json = {}; | |
1112 } | |
1113 if (json is Map) { | |
1114 String file; | |
1115 if (json.containsKey("file")) { | |
1116 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
1117 } else { | |
1118 throw jsonDecoder.missingKey(jsonPath, "file"); | |
1119 } | |
1120 int offset; | |
1121 if (json.containsKey("offset")) { | |
1122 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
1123 } else { | |
1124 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
1125 } | |
1126 int length; | |
1127 if (json.containsKey("length")) { | |
1128 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
1129 } else { | |
1130 throw jsonDecoder.missingKey(jsonPath, "length"); | |
1131 } | |
1132 return new AnalysisGetNavigationParams(file, offset, length); | |
1133 } else { | |
1134 throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation params", json
); | |
1135 } | |
1136 } | |
1137 | |
1138 factory AnalysisGetNavigationParams.fromRequest(Request request) { | |
1139 return new AnalysisGetNavigationParams.fromJson( | |
1140 new RequestDecoder(request), "params", request._params); | |
1141 } | |
1142 | |
1143 Map<String, dynamic> toJson() { | |
1144 Map<String, dynamic> result = {}; | |
1145 result["file"] = file; | |
1146 result["offset"] = offset; | |
1147 result["length"] = length; | |
1148 return result; | |
1149 } | |
1150 | |
1151 Request toRequest(String id) { | |
1152 return new Request(id, "analysis.getNavigation", toJson()); | |
1153 } | |
1154 | |
1155 @override | |
1156 String toString() => JSON.encode(toJson()); | |
1157 | |
1158 @override | |
1159 bool operator==(other) { | |
1160 if (other is AnalysisGetNavigationParams) { | |
1161 return file == other.file && | |
1162 offset == other.offset && | |
1163 length == other.length; | |
1164 } | |
1165 return false; | |
1166 } | |
1167 | |
1168 @override | |
1169 int get hashCode { | |
1170 int hash = 0; | |
1171 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
1172 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
1173 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
1174 return _JenkinsSmiHash.finish(hash); | |
1175 } | |
1176 } | |
1177 | |
1178 /** | |
1179 * analysis.getNavigation result | |
1180 * | |
1181 * { | |
1182 * "files": List<FilePath> | |
1183 * "targets": List<NavigationTarget> | |
1184 * "regions": List<NavigationRegion> | |
1185 * } | |
1186 */ | |
1187 class AnalysisGetNavigationResult implements HasToJson { | |
1188 List<String> _files; | |
1189 | |
1190 List<NavigationTarget> _targets; | |
1191 | |
1192 List<NavigationRegion> _regions; | |
1193 | |
1194 /** | |
1195 * A list of the paths of files that are referenced by the navigation | |
1196 * targets. | |
1197 */ | |
1198 List<String> get files => _files; | |
1199 | |
1200 /** | |
1201 * A list of the paths of files that are referenced by the navigation | |
1202 * targets. | |
1203 */ | |
1204 void set files(List<String> value) { | |
1205 assert(value != null); | |
1206 this._files = value; | |
1207 } | |
1208 | |
1209 /** | |
1210 * A list of the navigation targets that are referenced by the navigation | |
1211 * regions. | |
1212 */ | |
1213 List<NavigationTarget> get targets => _targets; | |
1214 | |
1215 /** | |
1216 * A list of the navigation targets that are referenced by the navigation | |
1217 * regions. | |
1218 */ | |
1219 void set targets(List<NavigationTarget> value) { | |
1220 assert(value != null); | |
1221 this._targets = value; | |
1222 } | |
1223 | |
1224 /** | |
1225 * A list of the navigation regions within the requested region of the file. | |
1226 */ | |
1227 List<NavigationRegion> get regions => _regions; | |
1228 | |
1229 /** | |
1230 * A list of the navigation regions within the requested region of the file. | |
1231 */ | |
1232 void set regions(List<NavigationRegion> value) { | |
1233 assert(value != null); | |
1234 this._regions = value; | |
1235 } | |
1236 | |
1237 AnalysisGetNavigationResult(List<String> files, List<NavigationTarget> targets
, List<NavigationRegion> regions) { | |
1238 this.files = files; | |
1239 this.targets = targets; | |
1240 this.regions = regions; | |
1241 } | |
1242 | |
1243 factory AnalysisGetNavigationResult.fromJson(JsonDecoder jsonDecoder, String j
sonPath, Object json) { | |
1244 if (json == null) { | |
1245 json = {}; | |
1246 } | |
1247 if (json is Map) { | |
1248 List<String> files; | |
1249 if (json.containsKey("files")) { | |
1250 files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], json
Decoder._decodeString); | |
1251 } else { | |
1252 throw jsonDecoder.missingKey(jsonPath, "files"); | |
1253 } | |
1254 List<NavigationTarget> targets; | |
1255 if (json.containsKey("targets")) { | |
1256 targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"]
, (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, j
sonPath, json)); | |
1257 } else { | |
1258 throw jsonDecoder.missingKey(jsonPath, "targets"); | |
1259 } | |
1260 List<NavigationRegion> regions; | |
1261 if (json.containsKey("regions")) { | |
1262 regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"]
, (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, j
sonPath, json)); | |
1263 } else { | |
1264 throw jsonDecoder.missingKey(jsonPath, "regions"); | |
1265 } | |
1266 return new AnalysisGetNavigationResult(files, targets, regions); | |
1267 } else { | |
1268 throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation result", json
); | |
1269 } | |
1270 } | |
1271 | |
1272 factory AnalysisGetNavigationResult.fromResponse(Response response) { | |
1273 return new AnalysisGetNavigationResult.fromJson( | |
1274 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
1275 } | |
1276 | |
1277 Map<String, dynamic> toJson() { | |
1278 Map<String, dynamic> result = {}; | |
1279 result["files"] = files; | |
1280 result["targets"] = targets.map((NavigationTarget value) => value.toJson()).
toList(); | |
1281 result["regions"] = regions.map((NavigationRegion value) => value.toJson()).
toList(); | |
1282 return result; | |
1283 } | |
1284 | |
1285 Response toResponse(String id) { | |
1286 return new Response(id, result: toJson()); | |
1287 } | |
1288 | |
1289 @override | |
1290 String toString() => JSON.encode(toJson()); | |
1291 | |
1292 @override | |
1293 bool operator==(other) { | |
1294 if (other is AnalysisGetNavigationResult) { | |
1295 return _listEqual(files, other.files, (String a, String b) => a == b) && | |
1296 _listEqual(targets, other.targets, (NavigationTarget a, NavigationTarg
et b) => a == b) && | |
1297 _listEqual(regions, other.regions, (NavigationRegion a, NavigationRegi
on b) => a == b); | |
1298 } | |
1299 return false; | |
1300 } | |
1301 | |
1302 @override | |
1303 int get hashCode { | |
1304 int hash = 0; | |
1305 hash = _JenkinsSmiHash.combine(hash, files.hashCode); | |
1306 hash = _JenkinsSmiHash.combine(hash, targets.hashCode); | |
1307 hash = _JenkinsSmiHash.combine(hash, regions.hashCode); | |
1308 return _JenkinsSmiHash.finish(hash); | |
1309 } | |
1310 } | |
1311 | |
1312 /** | |
1313 * analysis.reanalyze params | |
1314 * | |
1315 * { | |
1316 * "roots": optional List<FilePath> | |
1317 * } | |
1318 */ | |
1319 class AnalysisReanalyzeParams implements HasToJson { | |
1320 List<String> _roots; | |
1321 | |
1322 /** | |
1323 * A list of the analysis roots that are to be re-analyzed. | |
1324 */ | |
1325 List<String> get roots => _roots; | |
1326 | |
1327 /** | |
1328 * A list of the analysis roots that are to be re-analyzed. | |
1329 */ | |
1330 void set roots(List<String> value) { | |
1331 this._roots = value; | |
1332 } | |
1333 | |
1334 AnalysisReanalyzeParams({List<String> roots}) { | |
1335 this.roots = roots; | |
1336 } | |
1337 | |
1338 factory AnalysisReanalyzeParams.fromJson(JsonDecoder jsonDecoder, String jsonP
ath, Object json) { | |
1339 if (json == null) { | |
1340 json = {}; | |
1341 } | |
1342 if (json is Map) { | |
1343 List<String> roots; | |
1344 if (json.containsKey("roots")) { | |
1345 roots = jsonDecoder._decodeList(jsonPath + ".roots", json["roots"], json
Decoder._decodeString); | |
1346 } | |
1347 return new AnalysisReanalyzeParams(roots: roots); | |
1348 } else { | |
1349 throw jsonDecoder.mismatch(jsonPath, "analysis.reanalyze params", json); | |
1350 } | |
1351 } | |
1352 | |
1353 factory AnalysisReanalyzeParams.fromRequest(Request request) { | |
1354 return new AnalysisReanalyzeParams.fromJson( | |
1355 new RequestDecoder(request), "params", request._params); | |
1356 } | |
1357 | |
1358 Map<String, dynamic> toJson() { | |
1359 Map<String, dynamic> result = {}; | |
1360 if (roots != null) { | |
1361 result["roots"] = roots; | |
1362 } | |
1363 return result; | |
1364 } | |
1365 | |
1366 Request toRequest(String id) { | |
1367 return new Request(id, "analysis.reanalyze", toJson()); | |
1368 } | |
1369 | |
1370 @override | |
1371 String toString() => JSON.encode(toJson()); | |
1372 | |
1373 @override | |
1374 bool operator==(other) { | |
1375 if (other is AnalysisReanalyzeParams) { | |
1376 return _listEqual(roots, other.roots, (String a, String b) => a == b); | |
1377 } | |
1378 return false; | |
1379 } | |
1380 | |
1381 @override | |
1382 int get hashCode { | |
1383 int hash = 0; | |
1384 hash = _JenkinsSmiHash.combine(hash, roots.hashCode); | |
1385 return _JenkinsSmiHash.finish(hash); | |
1386 } | |
1387 } | |
1388 /** | |
1389 * analysis.reanalyze result | |
1390 */ | |
1391 class AnalysisReanalyzeResult { | |
1392 Response toResponse(String id) { | |
1393 return new Response(id, result: null); | |
1394 } | |
1395 | |
1396 @override | |
1397 bool operator==(other) { | |
1398 if (other is AnalysisReanalyzeResult) { | |
1399 return true; | |
1400 } | |
1401 return false; | |
1402 } | |
1403 | |
1404 @override | |
1405 int get hashCode { | |
1406 return 846803925; | |
1407 } | |
1408 } | |
1409 | |
1410 /** | |
1411 * analysis.setAnalysisRoots params | |
1412 * | |
1413 * { | |
1414 * "included": List<FilePath> | |
1415 * "excluded": List<FilePath> | |
1416 * "packageRoots": optional Map<FilePath, FilePath> | |
1417 * } | |
1418 */ | |
1419 class AnalysisSetAnalysisRootsParams implements HasToJson { | |
1420 List<String> _included; | |
1421 | |
1422 List<String> _excluded; | |
1423 | |
1424 Map<String, String> _packageRoots; | |
1425 | |
1426 /** | |
1427 * A list of the files and directories that should be analyzed. | |
1428 */ | |
1429 List<String> get included => _included; | |
1430 | |
1431 /** | |
1432 * A list of the files and directories that should be analyzed. | |
1433 */ | |
1434 void set included(List<String> value) { | |
1435 assert(value != null); | |
1436 this._included = value; | |
1437 } | |
1438 | |
1439 /** | |
1440 * A list of the files and directories within the included directories that | |
1441 * should not be analyzed. | |
1442 */ | |
1443 List<String> get excluded => _excluded; | |
1444 | |
1445 /** | |
1446 * A list of the files and directories within the included directories that | |
1447 * should not be analyzed. | |
1448 */ | |
1449 void set excluded(List<String> value) { | |
1450 assert(value != null); | |
1451 this._excluded = value; | |
1452 } | |
1453 | |
1454 /** | |
1455 * A mapping from source directories to target directories that should | |
1456 * override the normal package: URI resolution mechanism. The analyzer will | |
1457 * behave as though each source directory in the map contains a special | |
1458 * pubspec.yaml file which resolves any package: URI to the corresponding | |
1459 * path within the target directory. The effect is the same as specifying the | |
1460 * target directory as a "--package_root" parameter to the Dart VM when | |
1461 * executing any Dart file inside the source directory. | |
1462 * | |
1463 * Files in any directories that are not overridden by this mapping have | |
1464 * their package: URI's resolved using the normal pubspec.yaml mechanism. If | |
1465 * this field is absent, or the empty map is specified, that indicates that | |
1466 * the normal pubspec.yaml mechanism should always be used. | |
1467 */ | |
1468 Map<String, String> get packageRoots => _packageRoots; | |
1469 | |
1470 /** | |
1471 * A mapping from source directories to target directories that should | |
1472 * override the normal package: URI resolution mechanism. The analyzer will | |
1473 * behave as though each source directory in the map contains a special | |
1474 * pubspec.yaml file which resolves any package: URI to the corresponding | |
1475 * path within the target directory. The effect is the same as specifying the | |
1476 * target directory as a "--package_root" parameter to the Dart VM when | |
1477 * executing any Dart file inside the source directory. | |
1478 * | |
1479 * Files in any directories that are not overridden by this mapping have | |
1480 * their package: URI's resolved using the normal pubspec.yaml mechanism. If | |
1481 * this field is absent, or the empty map is specified, that indicates that | |
1482 * the normal pubspec.yaml mechanism should always be used. | |
1483 */ | |
1484 void set packageRoots(Map<String, String> value) { | |
1485 this._packageRoots = value; | |
1486 } | |
1487 | |
1488 AnalysisSetAnalysisRootsParams(List<String> included, List<String> excluded, {
Map<String, String> packageRoots}) { | |
1489 this.included = included; | |
1490 this.excluded = excluded; | |
1491 this.packageRoots = packageRoots; | |
1492 } | |
1493 | |
1494 factory AnalysisSetAnalysisRootsParams.fromJson(JsonDecoder jsonDecoder, Strin
g jsonPath, Object json) { | |
1495 if (json == null) { | |
1496 json = {}; | |
1497 } | |
1498 if (json is Map) { | |
1499 List<String> included; | |
1500 if (json.containsKey("included")) { | |
1501 included = jsonDecoder._decodeList(jsonPath + ".included", json["include
d"], jsonDecoder._decodeString); | |
1502 } else { | |
1503 throw jsonDecoder.missingKey(jsonPath, "included"); | |
1504 } | |
1505 List<String> excluded; | |
1506 if (json.containsKey("excluded")) { | |
1507 excluded = jsonDecoder._decodeList(jsonPath + ".excluded", json["exclude
d"], jsonDecoder._decodeString); | |
1508 } else { | |
1509 throw jsonDecoder.missingKey(jsonPath, "excluded"); | |
1510 } | |
1511 Map<String, String> packageRoots; | |
1512 if (json.containsKey("packageRoots")) { | |
1513 packageRoots = jsonDecoder._decodeMap(jsonPath + ".packageRoots", json["
packageRoots"], valueDecoder: jsonDecoder._decodeString); | |
1514 } | |
1515 return new AnalysisSetAnalysisRootsParams(included, excluded, packageRoots
: packageRoots); | |
1516 } else { | |
1517 throw jsonDecoder.mismatch(jsonPath, "analysis.setAnalysisRoots params", j
son); | |
1518 } | |
1519 } | |
1520 | |
1521 factory AnalysisSetAnalysisRootsParams.fromRequest(Request request) { | |
1522 return new AnalysisSetAnalysisRootsParams.fromJson( | |
1523 new RequestDecoder(request), "params", request._params); | |
1524 } | |
1525 | |
1526 Map<String, dynamic> toJson() { | |
1527 Map<String, dynamic> result = {}; | |
1528 result["included"] = included; | |
1529 result["excluded"] = excluded; | |
1530 if (packageRoots != null) { | |
1531 result["packageRoots"] = packageRoots; | |
1532 } | |
1533 return result; | |
1534 } | |
1535 | |
1536 Request toRequest(String id) { | |
1537 return new Request(id, "analysis.setAnalysisRoots", toJson()); | |
1538 } | |
1539 | |
1540 @override | |
1541 String toString() => JSON.encode(toJson()); | |
1542 | |
1543 @override | |
1544 bool operator==(other) { | |
1545 if (other is AnalysisSetAnalysisRootsParams) { | |
1546 return _listEqual(included, other.included, (String a, String b) => a == b
) && | |
1547 _listEqual(excluded, other.excluded, (String a, String b) => a == b) &
& | |
1548 _mapEqual(packageRoots, other.packageRoots, (String a, String b) => a
== b); | |
1549 } | |
1550 return false; | |
1551 } | |
1552 | |
1553 @override | |
1554 int get hashCode { | |
1555 int hash = 0; | |
1556 hash = _JenkinsSmiHash.combine(hash, included.hashCode); | |
1557 hash = _JenkinsSmiHash.combine(hash, excluded.hashCode); | |
1558 hash = _JenkinsSmiHash.combine(hash, packageRoots.hashCode); | |
1559 return _JenkinsSmiHash.finish(hash); | |
1560 } | |
1561 } | |
1562 /** | |
1563 * analysis.setAnalysisRoots result | |
1564 */ | |
1565 class AnalysisSetAnalysisRootsResult { | |
1566 Response toResponse(String id) { | |
1567 return new Response(id, result: null); | |
1568 } | |
1569 | |
1570 @override | |
1571 bool operator==(other) { | |
1572 if (other is AnalysisSetAnalysisRootsResult) { | |
1573 return true; | |
1574 } | |
1575 return false; | |
1576 } | |
1577 | |
1578 @override | |
1579 int get hashCode { | |
1580 return 866004753; | |
1581 } | |
1582 } | |
1583 | |
1584 /** | |
1585 * analysis.setGeneralSubscriptions params | |
1586 * | |
1587 * { | |
1588 * "subscriptions": List<GeneralAnalysisService> | |
1589 * } | |
1590 */ | |
1591 class AnalysisSetGeneralSubscriptionsParams implements HasToJson { | |
1592 List<GeneralAnalysisService> _subscriptions; | |
1593 | |
1594 /** | |
1595 * A list of the services being subscribed to. | |
1596 */ | |
1597 List<GeneralAnalysisService> get subscriptions => _subscriptions; | |
1598 | |
1599 /** | |
1600 * A list of the services being subscribed to. | |
1601 */ | |
1602 void set subscriptions(List<GeneralAnalysisService> value) { | |
1603 assert(value != null); | |
1604 this._subscriptions = value; | |
1605 } | |
1606 | |
1607 AnalysisSetGeneralSubscriptionsParams(List<GeneralAnalysisService> subscriptio
ns) { | |
1608 this.subscriptions = subscriptions; | |
1609 } | |
1610 | |
1611 factory AnalysisSetGeneralSubscriptionsParams.fromJson(JsonDecoder jsonDecoder
, String jsonPath, Object json) { | |
1612 if (json == null) { | |
1613 json = {}; | |
1614 } | |
1615 if (json is Map) { | |
1616 List<GeneralAnalysisService> subscriptions; | |
1617 if (json.containsKey("subscriptions")) { | |
1618 subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", jso
n["subscriptions"], (String jsonPath, Object json) => new GeneralAnalysisService
.fromJson(jsonDecoder, jsonPath, json)); | |
1619 } else { | |
1620 throw jsonDecoder.missingKey(jsonPath, "subscriptions"); | |
1621 } | |
1622 return new AnalysisSetGeneralSubscriptionsParams(subscriptions); | |
1623 } else { | |
1624 throw jsonDecoder.mismatch(jsonPath, "analysis.setGeneralSubscriptions par
ams", json); | |
1625 } | |
1626 } | |
1627 | |
1628 factory AnalysisSetGeneralSubscriptionsParams.fromRequest(Request request) { | |
1629 return new AnalysisSetGeneralSubscriptionsParams.fromJson( | |
1630 new RequestDecoder(request), "params", request._params); | |
1631 } | |
1632 | |
1633 Map<String, dynamic> toJson() { | |
1634 Map<String, dynamic> result = {}; | |
1635 result["subscriptions"] = subscriptions.map((GeneralAnalysisService value) =
> value.toJson()).toList(); | |
1636 return result; | |
1637 } | |
1638 | |
1639 Request toRequest(String id) { | |
1640 return new Request(id, "analysis.setGeneralSubscriptions", toJson()); | |
1641 } | |
1642 | |
1643 @override | |
1644 String toString() => JSON.encode(toJson()); | |
1645 | |
1646 @override | |
1647 bool operator==(other) { | |
1648 if (other is AnalysisSetGeneralSubscriptionsParams) { | |
1649 return _listEqual(subscriptions, other.subscriptions, (GeneralAnalysisServ
ice a, GeneralAnalysisService b) => a == b); | |
1650 } | |
1651 return false; | |
1652 } | |
1653 | |
1654 @override | |
1655 int get hashCode { | |
1656 int hash = 0; | |
1657 hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode); | |
1658 return _JenkinsSmiHash.finish(hash); | |
1659 } | |
1660 } | |
1661 /** | |
1662 * analysis.setGeneralSubscriptions result | |
1663 */ | |
1664 class AnalysisSetGeneralSubscriptionsResult { | |
1665 Response toResponse(String id) { | |
1666 return new Response(id, result: null); | |
1667 } | |
1668 | |
1669 @override | |
1670 bool operator==(other) { | |
1671 if (other is AnalysisSetGeneralSubscriptionsResult) { | |
1672 return true; | |
1673 } | |
1674 return false; | |
1675 } | |
1676 | |
1677 @override | |
1678 int get hashCode { | |
1679 return 386759562; | |
1680 } | |
1681 } | |
1682 | |
1683 /** | |
1684 * analysis.setPriorityFiles params | |
1685 * | |
1686 * { | |
1687 * "files": List<FilePath> | |
1688 * } | |
1689 */ | |
1690 class AnalysisSetPriorityFilesParams implements HasToJson { | |
1691 List<String> _files; | |
1692 | |
1693 /** | |
1694 * The files that are to be a priority for analysis. | |
1695 */ | |
1696 List<String> get files => _files; | |
1697 | |
1698 /** | |
1699 * The files that are to be a priority for analysis. | |
1700 */ | |
1701 void set files(List<String> value) { | |
1702 assert(value != null); | |
1703 this._files = value; | |
1704 } | |
1705 | |
1706 AnalysisSetPriorityFilesParams(List<String> files) { | |
1707 this.files = files; | |
1708 } | |
1709 | |
1710 factory AnalysisSetPriorityFilesParams.fromJson(JsonDecoder jsonDecoder, Strin
g jsonPath, Object json) { | |
1711 if (json == null) { | |
1712 json = {}; | |
1713 } | |
1714 if (json is Map) { | |
1715 List<String> files; | |
1716 if (json.containsKey("files")) { | |
1717 files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], json
Decoder._decodeString); | |
1718 } else { | |
1719 throw jsonDecoder.missingKey(jsonPath, "files"); | |
1720 } | |
1721 return new AnalysisSetPriorityFilesParams(files); | |
1722 } else { | |
1723 throw jsonDecoder.mismatch(jsonPath, "analysis.setPriorityFiles params", j
son); | |
1724 } | |
1725 } | |
1726 | |
1727 factory AnalysisSetPriorityFilesParams.fromRequest(Request request) { | |
1728 return new AnalysisSetPriorityFilesParams.fromJson( | |
1729 new RequestDecoder(request), "params", request._params); | |
1730 } | |
1731 | |
1732 Map<String, dynamic> toJson() { | |
1733 Map<String, dynamic> result = {}; | |
1734 result["files"] = files; | |
1735 return result; | |
1736 } | |
1737 | |
1738 Request toRequest(String id) { | |
1739 return new Request(id, "analysis.setPriorityFiles", toJson()); | |
1740 } | |
1741 | |
1742 @override | |
1743 String toString() => JSON.encode(toJson()); | |
1744 | |
1745 @override | |
1746 bool operator==(other) { | |
1747 if (other is AnalysisSetPriorityFilesParams) { | |
1748 return _listEqual(files, other.files, (String a, String b) => a == b); | |
1749 } | |
1750 return false; | |
1751 } | |
1752 | |
1753 @override | |
1754 int get hashCode { | |
1755 int hash = 0; | |
1756 hash = _JenkinsSmiHash.combine(hash, files.hashCode); | |
1757 return _JenkinsSmiHash.finish(hash); | |
1758 } | |
1759 } | |
1760 /** | |
1761 * analysis.setPriorityFiles result | |
1762 */ | |
1763 class AnalysisSetPriorityFilesResult { | |
1764 Response toResponse(String id) { | |
1765 return new Response(id, result: null); | |
1766 } | |
1767 | |
1768 @override | |
1769 bool operator==(other) { | |
1770 if (other is AnalysisSetPriorityFilesResult) { | |
1771 return true; | |
1772 } | |
1773 return false; | |
1774 } | |
1775 | |
1776 @override | |
1777 int get hashCode { | |
1778 return 330050055; | |
1779 } | |
1780 } | |
1781 | |
1782 /** | |
1783 * analysis.setSubscriptions params | |
1784 * | |
1785 * { | |
1786 * "subscriptions": Map<AnalysisService, List<FilePath>> | |
1787 * } | |
1788 */ | |
1789 class AnalysisSetSubscriptionsParams implements HasToJson { | |
1790 Map<AnalysisService, List<String>> _subscriptions; | |
1791 | |
1792 /** | |
1793 * A table mapping services to a list of the files being subscribed to the | |
1794 * service. | |
1795 */ | |
1796 Map<AnalysisService, List<String>> get subscriptions => _subscriptions; | |
1797 | |
1798 /** | |
1799 * A table mapping services to a list of the files being subscribed to the | |
1800 * service. | |
1801 */ | |
1802 void set subscriptions(Map<AnalysisService, List<String>> value) { | |
1803 assert(value != null); | |
1804 this._subscriptions = value; | |
1805 } | |
1806 | |
1807 AnalysisSetSubscriptionsParams(Map<AnalysisService, List<String>> subscription
s) { | |
1808 this.subscriptions = subscriptions; | |
1809 } | |
1810 | |
1811 factory AnalysisSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, Strin
g jsonPath, Object json) { | |
1812 if (json == null) { | |
1813 json = {}; | |
1814 } | |
1815 if (json is Map) { | |
1816 Map<AnalysisService, List<String>> subscriptions; | |
1817 if (json.containsKey("subscriptions")) { | |
1818 subscriptions = jsonDecoder._decodeMap(jsonPath + ".subscriptions", json
["subscriptions"], keyDecoder: (String jsonPath, Object json) => new AnalysisSer
vice.fromJson(jsonDecoder, jsonPath, json), valueDecoder: (String jsonPath, Obje
ct json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString)); | |
1819 } else { | |
1820 throw jsonDecoder.missingKey(jsonPath, "subscriptions"); | |
1821 } | |
1822 return new AnalysisSetSubscriptionsParams(subscriptions); | |
1823 } else { | |
1824 throw jsonDecoder.mismatch(jsonPath, "analysis.setSubscriptions params", j
son); | |
1825 } | |
1826 } | |
1827 | |
1828 factory AnalysisSetSubscriptionsParams.fromRequest(Request request) { | |
1829 return new AnalysisSetSubscriptionsParams.fromJson( | |
1830 new RequestDecoder(request), "params", request._params); | |
1831 } | |
1832 | |
1833 Map<String, dynamic> toJson() { | |
1834 Map<String, dynamic> result = {}; | |
1835 result["subscriptions"] = mapMap(subscriptions, keyCallback: (AnalysisServic
e value) => value.toJson()); | |
1836 return result; | |
1837 } | |
1838 | |
1839 Request toRequest(String id) { | |
1840 return new Request(id, "analysis.setSubscriptions", toJson()); | |
1841 } | |
1842 | |
1843 @override | |
1844 String toString() => JSON.encode(toJson()); | |
1845 | |
1846 @override | |
1847 bool operator==(other) { | |
1848 if (other is AnalysisSetSubscriptionsParams) { | |
1849 return _mapEqual(subscriptions, other.subscriptions, (List<String> a, List
<String> b) => _listEqual(a, b, (String a, String b) => a == b)); | |
1850 } | |
1851 return false; | |
1852 } | |
1853 | |
1854 @override | |
1855 int get hashCode { | |
1856 int hash = 0; | |
1857 hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode); | |
1858 return _JenkinsSmiHash.finish(hash); | |
1859 } | |
1860 } | |
1861 /** | |
1862 * analysis.setSubscriptions result | |
1863 */ | |
1864 class AnalysisSetSubscriptionsResult { | |
1865 Response toResponse(String id) { | |
1866 return new Response(id, result: null); | |
1867 } | |
1868 | |
1869 @override | |
1870 bool operator==(other) { | |
1871 if (other is AnalysisSetSubscriptionsResult) { | |
1872 return true; | |
1873 } | |
1874 return false; | |
1875 } | |
1876 | |
1877 @override | |
1878 int get hashCode { | |
1879 return 218088493; | |
1880 } | |
1881 } | |
1882 | |
1883 /** | |
1884 * analysis.updateContent params | |
1885 * | |
1886 * { | |
1887 * "files": Map<FilePath, AddContentOverlay | ChangeContentOverlay | RemoveCon
tentOverlay> | |
1888 * } | |
1889 */ | |
1890 class AnalysisUpdateContentParams implements HasToJson { | |
1891 Map<String, dynamic> _files; | |
1892 | |
1893 /** | |
1894 * A table mapping the files whose content has changed to a description of | |
1895 * the content change. | |
1896 */ | |
1897 Map<String, dynamic> get files => _files; | |
1898 | |
1899 /** | |
1900 * A table mapping the files whose content has changed to a description of | |
1901 * the content change. | |
1902 */ | |
1903 void set files(Map<String, dynamic> value) { | |
1904 assert(value != null); | |
1905 this._files = value; | |
1906 } | |
1907 | |
1908 AnalysisUpdateContentParams(Map<String, dynamic> files) { | |
1909 this.files = files; | |
1910 } | |
1911 | |
1912 factory AnalysisUpdateContentParams.fromJson(JsonDecoder jsonDecoder, String j
sonPath, Object json) { | |
1913 if (json == null) { | |
1914 json = {}; | |
1915 } | |
1916 if (json is Map) { | |
1917 Map<String, dynamic> files; | |
1918 if (json.containsKey("files")) { | |
1919 files = jsonDecoder._decodeMap(jsonPath + ".files", json["files"], value
Decoder: (String jsonPath, Object json) => jsonDecoder._decodeUnion(jsonPath, js
on, "type", {"add": (String jsonPath, Object json) => new AddContentOverlay.from
Json(jsonDecoder, jsonPath, json), "change": (String jsonPath, Object json) => n
ew ChangeContentOverlay.fromJson(jsonDecoder, jsonPath, json), "remove": (String
jsonPath, Object json) => new RemoveContentOverlay.fromJson(jsonDecoder, jsonPa
th, json)})); | |
1920 } else { | |
1921 throw jsonDecoder.missingKey(jsonPath, "files"); | |
1922 } | |
1923 return new AnalysisUpdateContentParams(files); | |
1924 } else { | |
1925 throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent params", json
); | |
1926 } | |
1927 } | |
1928 | |
1929 factory AnalysisUpdateContentParams.fromRequest(Request request) { | |
1930 return new AnalysisUpdateContentParams.fromJson( | |
1931 new RequestDecoder(request), "params", request._params); | |
1932 } | |
1933 | |
1934 Map<String, dynamic> toJson() { | |
1935 Map<String, dynamic> result = {}; | |
1936 result["files"] = mapMap(files, valueCallback: (dynamic value) => value.toJs
on()); | |
1937 return result; | |
1938 } | |
1939 | |
1940 Request toRequest(String id) { | |
1941 return new Request(id, "analysis.updateContent", toJson()); | |
1942 } | |
1943 | |
1944 @override | |
1945 String toString() => JSON.encode(toJson()); | |
1946 | |
1947 @override | |
1948 bool operator==(other) { | |
1949 if (other is AnalysisUpdateContentParams) { | |
1950 return _mapEqual(files, other.files, (dynamic a, dynamic b) => a == b); | |
1951 } | |
1952 return false; | |
1953 } | |
1954 | |
1955 @override | |
1956 int get hashCode { | |
1957 int hash = 0; | |
1958 hash = _JenkinsSmiHash.combine(hash, files.hashCode); | |
1959 return _JenkinsSmiHash.finish(hash); | |
1960 } | |
1961 } | |
1962 | |
1963 /** | |
1964 * analysis.updateContent result | |
1965 * | |
1966 * { | |
1967 * } | |
1968 */ | |
1969 class AnalysisUpdateContentResult implements HasToJson { | |
1970 AnalysisUpdateContentResult(); | |
1971 | |
1972 factory AnalysisUpdateContentResult.fromJson(JsonDecoder jsonDecoder, String j
sonPath, Object json) { | |
1973 if (json == null) { | |
1974 json = {}; | |
1975 } | |
1976 if (json is Map) { | |
1977 return new AnalysisUpdateContentResult(); | |
1978 } else { | |
1979 throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent result", json
); | |
1980 } | |
1981 } | |
1982 | |
1983 factory AnalysisUpdateContentResult.fromResponse(Response response) { | |
1984 return new AnalysisUpdateContentResult.fromJson( | |
1985 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
1986 } | |
1987 | |
1988 Map<String, dynamic> toJson() { | |
1989 Map<String, dynamic> result = {}; | |
1990 return result; | |
1991 } | |
1992 | |
1993 Response toResponse(String id) { | |
1994 return new Response(id, result: toJson()); | |
1995 } | |
1996 | |
1997 @override | |
1998 String toString() => JSON.encode(toJson()); | |
1999 | |
2000 @override | |
2001 bool operator==(other) { | |
2002 if (other is AnalysisUpdateContentResult) { | |
2003 return true; | |
2004 } | |
2005 return false; | |
2006 } | |
2007 | |
2008 @override | |
2009 int get hashCode { | |
2010 int hash = 0; | |
2011 return _JenkinsSmiHash.finish(hash); | |
2012 } | |
2013 } | |
2014 | |
2015 /** | |
2016 * analysis.updateOptions params | |
2017 * | |
2018 * { | |
2019 * "options": AnalysisOptions | |
2020 * } | |
2021 */ | |
2022 class AnalysisUpdateOptionsParams implements HasToJson { | |
2023 AnalysisOptions _options; | |
2024 | |
2025 /** | |
2026 * The options that are to be used to control analysis. | |
2027 */ | |
2028 AnalysisOptions get options => _options; | |
2029 | |
2030 /** | |
2031 * The options that are to be used to control analysis. | |
2032 */ | |
2033 void set options(AnalysisOptions value) { | |
2034 assert(value != null); | |
2035 this._options = value; | |
2036 } | |
2037 | |
2038 AnalysisUpdateOptionsParams(AnalysisOptions options) { | |
2039 this.options = options; | |
2040 } | |
2041 | |
2042 factory AnalysisUpdateOptionsParams.fromJson(JsonDecoder jsonDecoder, String j
sonPath, Object json) { | |
2043 if (json == null) { | |
2044 json = {}; | |
2045 } | |
2046 if (json is Map) { | |
2047 AnalysisOptions options; | |
2048 if (json.containsKey("options")) { | |
2049 options = new AnalysisOptions.fromJson(jsonDecoder, jsonPath + ".options
", json["options"]); | |
2050 } else { | |
2051 throw jsonDecoder.missingKey(jsonPath, "options"); | |
2052 } | |
2053 return new AnalysisUpdateOptionsParams(options); | |
2054 } else { | |
2055 throw jsonDecoder.mismatch(jsonPath, "analysis.updateOptions params", json
); | |
2056 } | |
2057 } | |
2058 | |
2059 factory AnalysisUpdateOptionsParams.fromRequest(Request request) { | |
2060 return new AnalysisUpdateOptionsParams.fromJson( | |
2061 new RequestDecoder(request), "params", request._params); | |
2062 } | |
2063 | |
2064 Map<String, dynamic> toJson() { | |
2065 Map<String, dynamic> result = {}; | |
2066 result["options"] = options.toJson(); | |
2067 return result; | |
2068 } | |
2069 | |
2070 Request toRequest(String id) { | |
2071 return new Request(id, "analysis.updateOptions", toJson()); | |
2072 } | |
2073 | |
2074 @override | |
2075 String toString() => JSON.encode(toJson()); | |
2076 | |
2077 @override | |
2078 bool operator==(other) { | |
2079 if (other is AnalysisUpdateOptionsParams) { | |
2080 return options == other.options; | |
2081 } | |
2082 return false; | |
2083 } | |
2084 | |
2085 @override | |
2086 int get hashCode { | |
2087 int hash = 0; | |
2088 hash = _JenkinsSmiHash.combine(hash, options.hashCode); | |
2089 return _JenkinsSmiHash.finish(hash); | |
2090 } | |
2091 } | |
2092 /** | |
2093 * analysis.updateOptions result | |
2094 */ | |
2095 class AnalysisUpdateOptionsResult { | |
2096 Response toResponse(String id) { | |
2097 return new Response(id, result: null); | |
2098 } | |
2099 | |
2100 @override | |
2101 bool operator==(other) { | |
2102 if (other is AnalysisUpdateOptionsResult) { | |
2103 return true; | |
2104 } | |
2105 return false; | |
2106 } | |
2107 | |
2108 @override | |
2109 int get hashCode { | |
2110 return 179689467; | |
2111 } | |
2112 } | |
2113 | |
2114 /** | |
2115 * analysis.analyzedFiles params | |
2116 * | |
2117 * { | |
2118 * "directories": List<FilePath> | |
2119 * } | |
2120 */ | |
2121 class AnalysisAnalyzedFilesParams implements HasToJson { | |
2122 List<String> _directories; | |
2123 | |
2124 /** | |
2125 * A list of the paths of the files that are being analyzed. | |
2126 */ | |
2127 List<String> get directories => _directories; | |
2128 | |
2129 /** | |
2130 * A list of the paths of the files that are being analyzed. | |
2131 */ | |
2132 void set directories(List<String> value) { | |
2133 assert(value != null); | |
2134 this._directories = value; | |
2135 } | |
2136 | |
2137 AnalysisAnalyzedFilesParams(List<String> directories) { | |
2138 this.directories = directories; | |
2139 } | |
2140 | |
2141 factory AnalysisAnalyzedFilesParams.fromJson(JsonDecoder jsonDecoder, String j
sonPath, Object json) { | |
2142 if (json == null) { | |
2143 json = {}; | |
2144 } | |
2145 if (json is Map) { | |
2146 List<String> directories; | |
2147 if (json.containsKey("directories")) { | |
2148 directories = jsonDecoder._decodeList(jsonPath + ".directories", json["d
irectories"], jsonDecoder._decodeString); | |
2149 } else { | |
2150 throw jsonDecoder.missingKey(jsonPath, "directories"); | |
2151 } | |
2152 return new AnalysisAnalyzedFilesParams(directories); | |
2153 } else { | |
2154 throw jsonDecoder.mismatch(jsonPath, "analysis.analyzedFiles params", json
); | |
2155 } | |
2156 } | |
2157 | |
2158 factory AnalysisAnalyzedFilesParams.fromNotification(Notification notification
) { | |
2159 return new AnalysisAnalyzedFilesParams.fromJson( | |
2160 new ResponseDecoder(null), "params", notification._params); | |
2161 } | |
2162 | |
2163 Map<String, dynamic> toJson() { | |
2164 Map<String, dynamic> result = {}; | |
2165 result["directories"] = directories; | |
2166 return result; | |
2167 } | |
2168 | |
2169 Notification toNotification() { | |
2170 return new Notification("analysis.analyzedFiles", toJson()); | |
2171 } | |
2172 | |
2173 @override | |
2174 String toString() => JSON.encode(toJson()); | |
2175 | |
2176 @override | |
2177 bool operator==(other) { | |
2178 if (other is AnalysisAnalyzedFilesParams) { | |
2179 return _listEqual(directories, other.directories, (String a, String b) =>
a == b); | |
2180 } | |
2181 return false; | |
2182 } | |
2183 | |
2184 @override | |
2185 int get hashCode { | |
2186 int hash = 0; | |
2187 hash = _JenkinsSmiHash.combine(hash, directories.hashCode); | |
2188 return _JenkinsSmiHash.finish(hash); | |
2189 } | |
2190 } | |
2191 | |
2192 /** | |
2193 * analysis.errors params | |
2194 * | |
2195 * { | |
2196 * "file": FilePath | |
2197 * "errors": List<AnalysisError> | |
2198 * } | |
2199 */ | |
2200 class AnalysisErrorsParams implements HasToJson { | |
2201 String _file; | |
2202 | |
2203 List<AnalysisError> _errors; | |
2204 | |
2205 /** | |
2206 * The file containing the errors. | |
2207 */ | |
2208 String get file => _file; | |
2209 | |
2210 /** | |
2211 * The file containing the errors. | |
2212 */ | |
2213 void set file(String value) { | |
2214 assert(value != null); | |
2215 this._file = value; | |
2216 } | |
2217 | |
2218 /** | |
2219 * The errors contained in the file. | |
2220 */ | |
2221 List<AnalysisError> get errors => _errors; | |
2222 | |
2223 /** | |
2224 * The errors contained in the file. | |
2225 */ | |
2226 void set errors(List<AnalysisError> value) { | |
2227 assert(value != null); | |
2228 this._errors = value; | |
2229 } | |
2230 | |
2231 AnalysisErrorsParams(String file, List<AnalysisError> errors) { | |
2232 this.file = file; | |
2233 this.errors = errors; | |
2234 } | |
2235 | |
2236 factory AnalysisErrorsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath
, Object json) { | |
2237 if (json == null) { | |
2238 json = {}; | |
2239 } | |
2240 if (json is Map) { | |
2241 String file; | |
2242 if (json.containsKey("file")) { | |
2243 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
2244 } else { | |
2245 throw jsonDecoder.missingKey(jsonPath, "file"); | |
2246 } | |
2247 List<AnalysisError> errors; | |
2248 if (json.containsKey("errors")) { | |
2249 errors = jsonDecoder._decodeList(jsonPath + ".errors", json["errors"], (
String jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPat
h, json)); | |
2250 } else { | |
2251 throw jsonDecoder.missingKey(jsonPath, "errors"); | |
2252 } | |
2253 return new AnalysisErrorsParams(file, errors); | |
2254 } else { | |
2255 throw jsonDecoder.mismatch(jsonPath, "analysis.errors params", json); | |
2256 } | |
2257 } | |
2258 | |
2259 factory AnalysisErrorsParams.fromNotification(Notification notification) { | |
2260 return new AnalysisErrorsParams.fromJson( | |
2261 new ResponseDecoder(null), "params", notification._params); | |
2262 } | |
2263 | |
2264 Map<String, dynamic> toJson() { | |
2265 Map<String, dynamic> result = {}; | |
2266 result["file"] = file; | |
2267 result["errors"] = errors.map((AnalysisError value) => value.toJson()).toLis
t(); | |
2268 return result; | |
2269 } | |
2270 | |
2271 Notification toNotification() { | |
2272 return new Notification("analysis.errors", toJson()); | |
2273 } | |
2274 | |
2275 @override | |
2276 String toString() => JSON.encode(toJson()); | |
2277 | |
2278 @override | |
2279 bool operator==(other) { | |
2280 if (other is AnalysisErrorsParams) { | |
2281 return file == other.file && | |
2282 _listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) =>
a == b); | |
2283 } | |
2284 return false; | |
2285 } | |
2286 | |
2287 @override | |
2288 int get hashCode { | |
2289 int hash = 0; | |
2290 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
2291 hash = _JenkinsSmiHash.combine(hash, errors.hashCode); | |
2292 return _JenkinsSmiHash.finish(hash); | |
2293 } | |
2294 } | |
2295 | |
2296 /** | |
2297 * analysis.flushResults params | |
2298 * | |
2299 * { | |
2300 * "files": List<FilePath> | |
2301 * } | |
2302 */ | |
2303 class AnalysisFlushResultsParams implements HasToJson { | |
2304 List<String> _files; | |
2305 | |
2306 /** | |
2307 * The files that are no longer being analyzed. | |
2308 */ | |
2309 List<String> get files => _files; | |
2310 | |
2311 /** | |
2312 * The files that are no longer being analyzed. | |
2313 */ | |
2314 void set files(List<String> value) { | |
2315 assert(value != null); | |
2316 this._files = value; | |
2317 } | |
2318 | |
2319 AnalysisFlushResultsParams(List<String> files) { | |
2320 this.files = files; | |
2321 } | |
2322 | |
2323 factory AnalysisFlushResultsParams.fromJson(JsonDecoder jsonDecoder, String js
onPath, Object json) { | |
2324 if (json == null) { | |
2325 json = {}; | |
2326 } | |
2327 if (json is Map) { | |
2328 List<String> files; | |
2329 if (json.containsKey("files")) { | |
2330 files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], json
Decoder._decodeString); | |
2331 } else { | |
2332 throw jsonDecoder.missingKey(jsonPath, "files"); | |
2333 } | |
2334 return new AnalysisFlushResultsParams(files); | |
2335 } else { | |
2336 throw jsonDecoder.mismatch(jsonPath, "analysis.flushResults params", json)
; | |
2337 } | |
2338 } | |
2339 | |
2340 factory AnalysisFlushResultsParams.fromNotification(Notification notification)
{ | |
2341 return new AnalysisFlushResultsParams.fromJson( | |
2342 new ResponseDecoder(null), "params", notification._params); | |
2343 } | |
2344 | |
2345 Map<String, dynamic> toJson() { | |
2346 Map<String, dynamic> result = {}; | |
2347 result["files"] = files; | |
2348 return result; | |
2349 } | |
2350 | |
2351 Notification toNotification() { | |
2352 return new Notification("analysis.flushResults", toJson()); | |
2353 } | |
2354 | |
2355 @override | |
2356 String toString() => JSON.encode(toJson()); | |
2357 | |
2358 @override | |
2359 bool operator==(other) { | |
2360 if (other is AnalysisFlushResultsParams) { | |
2361 return _listEqual(files, other.files, (String a, String b) => a == b); | |
2362 } | |
2363 return false; | |
2364 } | |
2365 | |
2366 @override | |
2367 int get hashCode { | |
2368 int hash = 0; | |
2369 hash = _JenkinsSmiHash.combine(hash, files.hashCode); | |
2370 return _JenkinsSmiHash.finish(hash); | |
2371 } | |
2372 } | |
2373 | |
2374 /** | |
2375 * analysis.folding params | |
2376 * | |
2377 * { | |
2378 * "file": FilePath | |
2379 * "regions": List<FoldingRegion> | |
2380 * } | |
2381 */ | |
2382 class AnalysisFoldingParams implements HasToJson { | |
2383 String _file; | |
2384 | |
2385 List<FoldingRegion> _regions; | |
2386 | |
2387 /** | |
2388 * The file containing the folding regions. | |
2389 */ | |
2390 String get file => _file; | |
2391 | |
2392 /** | |
2393 * The file containing the folding regions. | |
2394 */ | |
2395 void set file(String value) { | |
2396 assert(value != null); | |
2397 this._file = value; | |
2398 } | |
2399 | |
2400 /** | |
2401 * The folding regions contained in the file. | |
2402 */ | |
2403 List<FoldingRegion> get regions => _regions; | |
2404 | |
2405 /** | |
2406 * The folding regions contained in the file. | |
2407 */ | |
2408 void set regions(List<FoldingRegion> value) { | |
2409 assert(value != null); | |
2410 this._regions = value; | |
2411 } | |
2412 | |
2413 AnalysisFoldingParams(String file, List<FoldingRegion> regions) { | |
2414 this.file = file; | |
2415 this.regions = regions; | |
2416 } | |
2417 | |
2418 factory AnalysisFoldingParams.fromJson(JsonDecoder jsonDecoder, String jsonPat
h, Object json) { | |
2419 if (json == null) { | |
2420 json = {}; | |
2421 } | |
2422 if (json is Map) { | |
2423 String file; | |
2424 if (json.containsKey("file")) { | |
2425 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
2426 } else { | |
2427 throw jsonDecoder.missingKey(jsonPath, "file"); | |
2428 } | |
2429 List<FoldingRegion> regions; | |
2430 if (json.containsKey("regions")) { | |
2431 regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"]
, (String jsonPath, Object json) => new FoldingRegion.fromJson(jsonDecoder, json
Path, json)); | |
2432 } else { | |
2433 throw jsonDecoder.missingKey(jsonPath, "regions"); | |
2434 } | |
2435 return new AnalysisFoldingParams(file, regions); | |
2436 } else { | |
2437 throw jsonDecoder.mismatch(jsonPath, "analysis.folding params", json); | |
2438 } | |
2439 } | |
2440 | |
2441 factory AnalysisFoldingParams.fromNotification(Notification notification) { | |
2442 return new AnalysisFoldingParams.fromJson( | |
2443 new ResponseDecoder(null), "params", notification._params); | |
2444 } | |
2445 | |
2446 Map<String, dynamic> toJson() { | |
2447 Map<String, dynamic> result = {}; | |
2448 result["file"] = file; | |
2449 result["regions"] = regions.map((FoldingRegion value) => value.toJson()).toL
ist(); | |
2450 return result; | |
2451 } | |
2452 | |
2453 Notification toNotification() { | |
2454 return new Notification("analysis.folding", toJson()); | |
2455 } | |
2456 | |
2457 @override | |
2458 String toString() => JSON.encode(toJson()); | |
2459 | |
2460 @override | |
2461 bool operator==(other) { | |
2462 if (other is AnalysisFoldingParams) { | |
2463 return file == other.file && | |
2464 _listEqual(regions, other.regions, (FoldingRegion a, FoldingRegion b)
=> a == b); | |
2465 } | |
2466 return false; | |
2467 } | |
2468 | |
2469 @override | |
2470 int get hashCode { | |
2471 int hash = 0; | |
2472 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
2473 hash = _JenkinsSmiHash.combine(hash, regions.hashCode); | |
2474 return _JenkinsSmiHash.finish(hash); | |
2475 } | |
2476 } | |
2477 | |
2478 /** | |
2479 * analysis.highlights params | |
2480 * | |
2481 * { | |
2482 * "file": FilePath | |
2483 * "regions": List<HighlightRegion> | |
2484 * } | |
2485 */ | |
2486 class AnalysisHighlightsParams implements HasToJson { | |
2487 String _file; | |
2488 | |
2489 List<HighlightRegion> _regions; | |
2490 | |
2491 /** | |
2492 * The file containing the highlight regions. | |
2493 */ | |
2494 String get file => _file; | |
2495 | |
2496 /** | |
2497 * The file containing the highlight regions. | |
2498 */ | |
2499 void set file(String value) { | |
2500 assert(value != null); | |
2501 this._file = value; | |
2502 } | |
2503 | |
2504 /** | |
2505 * The highlight regions contained in the file. Each highlight region | |
2506 * represents a particular syntactic or semantic meaning associated with some | |
2507 * range. Note that the highlight regions that are returned can overlap other | |
2508 * highlight regions if there is more than one meaning associated with a | |
2509 * particular region. | |
2510 */ | |
2511 List<HighlightRegion> get regions => _regions; | |
2512 | |
2513 /** | |
2514 * The highlight regions contained in the file. Each highlight region | |
2515 * represents a particular syntactic or semantic meaning associated with some | |
2516 * range. Note that the highlight regions that are returned can overlap other | |
2517 * highlight regions if there is more than one meaning associated with a | |
2518 * particular region. | |
2519 */ | |
2520 void set regions(List<HighlightRegion> value) { | |
2521 assert(value != null); | |
2522 this._regions = value; | |
2523 } | |
2524 | |
2525 AnalysisHighlightsParams(String file, List<HighlightRegion> regions) { | |
2526 this.file = file; | |
2527 this.regions = regions; | |
2528 } | |
2529 | |
2530 factory AnalysisHighlightsParams.fromJson(JsonDecoder jsonDecoder, String json
Path, Object json) { | |
2531 if (json == null) { | |
2532 json = {}; | |
2533 } | |
2534 if (json is Map) { | |
2535 String file; | |
2536 if (json.containsKey("file")) { | |
2537 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
2538 } else { | |
2539 throw jsonDecoder.missingKey(jsonPath, "file"); | |
2540 } | |
2541 List<HighlightRegion> regions; | |
2542 if (json.containsKey("regions")) { | |
2543 regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"]
, (String jsonPath, Object json) => new HighlightRegion.fromJson(jsonDecoder, js
onPath, json)); | |
2544 } else { | |
2545 throw jsonDecoder.missingKey(jsonPath, "regions"); | |
2546 } | |
2547 return new AnalysisHighlightsParams(file, regions); | |
2548 } else { | |
2549 throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params", json); | |
2550 } | |
2551 } | |
2552 | |
2553 factory AnalysisHighlightsParams.fromNotification(Notification notification) { | |
2554 return new AnalysisHighlightsParams.fromJson( | |
2555 new ResponseDecoder(null), "params", notification._params); | |
2556 } | |
2557 | |
2558 Map<String, dynamic> toJson() { | |
2559 Map<String, dynamic> result = {}; | |
2560 result["file"] = file; | |
2561 result["regions"] = regions.map((HighlightRegion value) => value.toJson()).t
oList(); | |
2562 return result; | |
2563 } | |
2564 | |
2565 Notification toNotification() { | |
2566 return new Notification("analysis.highlights", toJson()); | |
2567 } | |
2568 | |
2569 @override | |
2570 String toString() => JSON.encode(toJson()); | |
2571 | |
2572 @override | |
2573 bool operator==(other) { | |
2574 if (other is AnalysisHighlightsParams) { | |
2575 return file == other.file && | |
2576 _listEqual(regions, other.regions, (HighlightRegion a, HighlightRegion
b) => a == b); | |
2577 } | |
2578 return false; | |
2579 } | |
2580 | |
2581 @override | |
2582 int get hashCode { | |
2583 int hash = 0; | |
2584 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
2585 hash = _JenkinsSmiHash.combine(hash, regions.hashCode); | |
2586 return _JenkinsSmiHash.finish(hash); | |
2587 } | |
2588 } | |
2589 | |
2590 /** | |
2591 * analysis.implemented params | |
2592 * | |
2593 * { | |
2594 * "file": FilePath | |
2595 * "classes": List<ImplementedClass> | |
2596 * "members": List<ImplementedMember> | |
2597 * } | |
2598 */ | |
2599 class AnalysisImplementedParams implements HasToJson { | |
2600 String _file; | |
2601 | |
2602 List<ImplementedClass> _classes; | |
2603 | |
2604 List<ImplementedMember> _members; | |
2605 | |
2606 /** | |
2607 * The file with which the implementations are associated. | |
2608 */ | |
2609 String get file => _file; | |
2610 | |
2611 /** | |
2612 * The file with which the implementations are associated. | |
2613 */ | |
2614 void set file(String value) { | |
2615 assert(value != null); | |
2616 this._file = value; | |
2617 } | |
2618 | |
2619 /** | |
2620 * The classes defined in the file that are implemented or extended. | |
2621 */ | |
2622 List<ImplementedClass> get classes => _classes; | |
2623 | |
2624 /** | |
2625 * The classes defined in the file that are implemented or extended. | |
2626 */ | |
2627 void set classes(List<ImplementedClass> value) { | |
2628 assert(value != null); | |
2629 this._classes = value; | |
2630 } | |
2631 | |
2632 /** | |
2633 * The member defined in the file that are implemented or overridden. | |
2634 */ | |
2635 List<ImplementedMember> get members => _members; | |
2636 | |
2637 /** | |
2638 * The member defined in the file that are implemented or overridden. | |
2639 */ | |
2640 void set members(List<ImplementedMember> value) { | |
2641 assert(value != null); | |
2642 this._members = value; | |
2643 } | |
2644 | |
2645 AnalysisImplementedParams(String file, List<ImplementedClass> classes, List<Im
plementedMember> members) { | |
2646 this.file = file; | |
2647 this.classes = classes; | |
2648 this.members = members; | |
2649 } | |
2650 | |
2651 factory AnalysisImplementedParams.fromJson(JsonDecoder jsonDecoder, String jso
nPath, Object json) { | |
2652 if (json == null) { | |
2653 json = {}; | |
2654 } | |
2655 if (json is Map) { | |
2656 String file; | |
2657 if (json.containsKey("file")) { | |
2658 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
2659 } else { | |
2660 throw jsonDecoder.missingKey(jsonPath, "file"); | |
2661 } | |
2662 List<ImplementedClass> classes; | |
2663 if (json.containsKey("classes")) { | |
2664 classes = jsonDecoder._decodeList(jsonPath + ".classes", json["classes"]
, (String jsonPath, Object json) => new ImplementedClass.fromJson(jsonDecoder, j
sonPath, json)); | |
2665 } else { | |
2666 throw jsonDecoder.missingKey(jsonPath, "classes"); | |
2667 } | |
2668 List<ImplementedMember> members; | |
2669 if (json.containsKey("members")) { | |
2670 members = jsonDecoder._decodeList(jsonPath + ".members", json["members"]
, (String jsonPath, Object json) => new ImplementedMember.fromJson(jsonDecoder,
jsonPath, json)); | |
2671 } else { | |
2672 throw jsonDecoder.missingKey(jsonPath, "members"); | |
2673 } | |
2674 return new AnalysisImplementedParams(file, classes, members); | |
2675 } else { | |
2676 throw jsonDecoder.mismatch(jsonPath, "analysis.implemented params", json); | |
2677 } | |
2678 } | |
2679 | |
2680 factory AnalysisImplementedParams.fromNotification(Notification notification)
{ | |
2681 return new AnalysisImplementedParams.fromJson( | |
2682 new ResponseDecoder(null), "params", notification._params); | |
2683 } | |
2684 | |
2685 Map<String, dynamic> toJson() { | |
2686 Map<String, dynamic> result = {}; | |
2687 result["file"] = file; | |
2688 result["classes"] = classes.map((ImplementedClass value) => value.toJson()).
toList(); | |
2689 result["members"] = members.map((ImplementedMember value) => value.toJson())
.toList(); | |
2690 return result; | |
2691 } | |
2692 | |
2693 Notification toNotification() { | |
2694 return new Notification("analysis.implemented", toJson()); | |
2695 } | |
2696 | |
2697 @override | |
2698 String toString() => JSON.encode(toJson()); | |
2699 | |
2700 @override | |
2701 bool operator==(other) { | |
2702 if (other is AnalysisImplementedParams) { | |
2703 return file == other.file && | |
2704 _listEqual(classes, other.classes, (ImplementedClass a, ImplementedCla
ss b) => a == b) && | |
2705 _listEqual(members, other.members, (ImplementedMember a, ImplementedMe
mber b) => a == b); | |
2706 } | |
2707 return false; | |
2708 } | |
2709 | |
2710 @override | |
2711 int get hashCode { | |
2712 int hash = 0; | |
2713 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
2714 hash = _JenkinsSmiHash.combine(hash, classes.hashCode); | |
2715 hash = _JenkinsSmiHash.combine(hash, members.hashCode); | |
2716 return _JenkinsSmiHash.finish(hash); | |
2717 } | |
2718 } | |
2719 | |
2720 /** | |
2721 * analysis.invalidate params | |
2722 * | |
2723 * { | |
2724 * "file": FilePath | |
2725 * "offset": int | |
2726 * "length": int | |
2727 * "delta": int | |
2728 * } | |
2729 */ | |
2730 class AnalysisInvalidateParams implements HasToJson { | |
2731 String _file; | |
2732 | |
2733 int _offset; | |
2734 | |
2735 int _length; | |
2736 | |
2737 int _delta; | |
2738 | |
2739 /** | |
2740 * The file whose information has been invalidated. | |
2741 */ | |
2742 String get file => _file; | |
2743 | |
2744 /** | |
2745 * The file whose information has been invalidated. | |
2746 */ | |
2747 void set file(String value) { | |
2748 assert(value != null); | |
2749 this._file = value; | |
2750 } | |
2751 | |
2752 /** | |
2753 * The offset of the invalidated region. | |
2754 */ | |
2755 int get offset => _offset; | |
2756 | |
2757 /** | |
2758 * The offset of the invalidated region. | |
2759 */ | |
2760 void set offset(int value) { | |
2761 assert(value != null); | |
2762 this._offset = value; | |
2763 } | |
2764 | |
2765 /** | |
2766 * The length of the invalidated region. | |
2767 */ | |
2768 int get length => _length; | |
2769 | |
2770 /** | |
2771 * The length of the invalidated region. | |
2772 */ | |
2773 void set length(int value) { | |
2774 assert(value != null); | |
2775 this._length = value; | |
2776 } | |
2777 | |
2778 /** | |
2779 * The delta to be applied to the offsets in information that follows the | |
2780 * invalidated region in order to update it so that it doesn't need to be | |
2781 * re-requested. | |
2782 */ | |
2783 int get delta => _delta; | |
2784 | |
2785 /** | |
2786 * The delta to be applied to the offsets in information that follows the | |
2787 * invalidated region in order to update it so that it doesn't need to be | |
2788 * re-requested. | |
2789 */ | |
2790 void set delta(int value) { | |
2791 assert(value != null); | |
2792 this._delta = value; | |
2793 } | |
2794 | |
2795 AnalysisInvalidateParams(String file, int offset, int length, int delta) { | |
2796 this.file = file; | |
2797 this.offset = offset; | |
2798 this.length = length; | |
2799 this.delta = delta; | |
2800 } | |
2801 | |
2802 factory AnalysisInvalidateParams.fromJson(JsonDecoder jsonDecoder, String json
Path, Object json) { | |
2803 if (json == null) { | |
2804 json = {}; | |
2805 } | |
2806 if (json is Map) { | |
2807 String file; | |
2808 if (json.containsKey("file")) { | |
2809 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
2810 } else { | |
2811 throw jsonDecoder.missingKey(jsonPath, "file"); | |
2812 } | |
2813 int offset; | |
2814 if (json.containsKey("offset")) { | |
2815 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
2816 } else { | |
2817 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
2818 } | |
2819 int length; | |
2820 if (json.containsKey("length")) { | |
2821 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
2822 } else { | |
2823 throw jsonDecoder.missingKey(jsonPath, "length"); | |
2824 } | |
2825 int delta; | |
2826 if (json.containsKey("delta")) { | |
2827 delta = jsonDecoder._decodeInt(jsonPath + ".delta", json["delta"]); | |
2828 } else { | |
2829 throw jsonDecoder.missingKey(jsonPath, "delta"); | |
2830 } | |
2831 return new AnalysisInvalidateParams(file, offset, length, delta); | |
2832 } else { | |
2833 throw jsonDecoder.mismatch(jsonPath, "analysis.invalidate params", json); | |
2834 } | |
2835 } | |
2836 | |
2837 factory AnalysisInvalidateParams.fromNotification(Notification notification) { | |
2838 return new AnalysisInvalidateParams.fromJson( | |
2839 new ResponseDecoder(null), "params", notification._params); | |
2840 } | |
2841 | |
2842 Map<String, dynamic> toJson() { | |
2843 Map<String, dynamic> result = {}; | |
2844 result["file"] = file; | |
2845 result["offset"] = offset; | |
2846 result["length"] = length; | |
2847 result["delta"] = delta; | |
2848 return result; | |
2849 } | |
2850 | |
2851 Notification toNotification() { | |
2852 return new Notification("analysis.invalidate", toJson()); | |
2853 } | |
2854 | |
2855 @override | |
2856 String toString() => JSON.encode(toJson()); | |
2857 | |
2858 @override | |
2859 bool operator==(other) { | |
2860 if (other is AnalysisInvalidateParams) { | |
2861 return file == other.file && | |
2862 offset == other.offset && | |
2863 length == other.length && | |
2864 delta == other.delta; | |
2865 } | |
2866 return false; | |
2867 } | |
2868 | |
2869 @override | |
2870 int get hashCode { | |
2871 int hash = 0; | |
2872 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
2873 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
2874 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
2875 hash = _JenkinsSmiHash.combine(hash, delta.hashCode); | |
2876 return _JenkinsSmiHash.finish(hash); | |
2877 } | |
2878 } | |
2879 | |
2880 /** | |
2881 * analysis.navigation params | |
2882 * | |
2883 * { | |
2884 * "file": FilePath | |
2885 * "regions": List<NavigationRegion> | |
2886 * "targets": List<NavigationTarget> | |
2887 * "files": List<FilePath> | |
2888 * } | |
2889 */ | |
2890 class AnalysisNavigationParams implements HasToJson { | |
2891 String _file; | |
2892 | |
2893 List<NavigationRegion> _regions; | |
2894 | |
2895 List<NavigationTarget> _targets; | |
2896 | |
2897 List<String> _files; | |
2898 | |
2899 /** | |
2900 * The file containing the navigation regions. | |
2901 */ | |
2902 String get file => _file; | |
2903 | |
2904 /** | |
2905 * The file containing the navigation regions. | |
2906 */ | |
2907 void set file(String value) { | |
2908 assert(value != null); | |
2909 this._file = value; | |
2910 } | |
2911 | |
2912 /** | |
2913 * The navigation regions contained in the file. The regions are sorted by | |
2914 * their offsets. Each navigation region represents a list of targets | |
2915 * associated with some range. The lists will usually contain a single | |
2916 * target, but can contain more in the case of a part that is included in | |
2917 * multiple libraries or in Dart code that is compiled against multiple | |
2918 * versions of a package. Note that the navigation regions that are returned | |
2919 * do not overlap other navigation regions. | |
2920 */ | |
2921 List<NavigationRegion> get regions => _regions; | |
2922 | |
2923 /** | |
2924 * The navigation regions contained in the file. The regions are sorted by | |
2925 * their offsets. Each navigation region represents a list of targets | |
2926 * associated with some range. The lists will usually contain a single | |
2927 * target, but can contain more in the case of a part that is included in | |
2928 * multiple libraries or in Dart code that is compiled against multiple | |
2929 * versions of a package. Note that the navigation regions that are returned | |
2930 * do not overlap other navigation regions. | |
2931 */ | |
2932 void set regions(List<NavigationRegion> value) { | |
2933 assert(value != null); | |
2934 this._regions = value; | |
2935 } | |
2936 | |
2937 /** | |
2938 * The navigation targets referenced in the file. They are referenced by | |
2939 * NavigationRegions by their index in this array. | |
2940 */ | |
2941 List<NavigationTarget> get targets => _targets; | |
2942 | |
2943 /** | |
2944 * The navigation targets referenced in the file. They are referenced by | |
2945 * NavigationRegions by their index in this array. | |
2946 */ | |
2947 void set targets(List<NavigationTarget> value) { | |
2948 assert(value != null); | |
2949 this._targets = value; | |
2950 } | |
2951 | |
2952 /** | |
2953 * The files containing navigation targets referenced in the file. They are | |
2954 * referenced by NavigationTargets by their index in this array. | |
2955 */ | |
2956 List<String> get files => _files; | |
2957 | |
2958 /** | |
2959 * The files containing navigation targets referenced in the file. They are | |
2960 * referenced by NavigationTargets by their index in this array. | |
2961 */ | |
2962 void set files(List<String> value) { | |
2963 assert(value != null); | |
2964 this._files = value; | |
2965 } | |
2966 | |
2967 AnalysisNavigationParams(String file, List<NavigationRegion> regions, List<Nav
igationTarget> targets, List<String> files) { | |
2968 this.file = file; | |
2969 this.regions = regions; | |
2970 this.targets = targets; | |
2971 this.files = files; | |
2972 } | |
2973 | |
2974 factory AnalysisNavigationParams.fromJson(JsonDecoder jsonDecoder, String json
Path, Object json) { | |
2975 if (json == null) { | |
2976 json = {}; | |
2977 } | |
2978 if (json is Map) { | |
2979 String file; | |
2980 if (json.containsKey("file")) { | |
2981 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
2982 } else { | |
2983 throw jsonDecoder.missingKey(jsonPath, "file"); | |
2984 } | |
2985 List<NavigationRegion> regions; | |
2986 if (json.containsKey("regions")) { | |
2987 regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"]
, (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, j
sonPath, json)); | |
2988 } else { | |
2989 throw jsonDecoder.missingKey(jsonPath, "regions"); | |
2990 } | |
2991 List<NavigationTarget> targets; | |
2992 if (json.containsKey("targets")) { | |
2993 targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"]
, (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, j
sonPath, json)); | |
2994 } else { | |
2995 throw jsonDecoder.missingKey(jsonPath, "targets"); | |
2996 } | |
2997 List<String> files; | |
2998 if (json.containsKey("files")) { | |
2999 files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], json
Decoder._decodeString); | |
3000 } else { | |
3001 throw jsonDecoder.missingKey(jsonPath, "files"); | |
3002 } | |
3003 return new AnalysisNavigationParams(file, regions, targets, files); | |
3004 } else { | |
3005 throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params", json); | |
3006 } | |
3007 } | |
3008 | |
3009 factory AnalysisNavigationParams.fromNotification(Notification notification) { | |
3010 return new AnalysisNavigationParams.fromJson( | |
3011 new ResponseDecoder(null), "params", notification._params); | |
3012 } | |
3013 | |
3014 Map<String, dynamic> toJson() { | |
3015 Map<String, dynamic> result = {}; | |
3016 result["file"] = file; | |
3017 result["regions"] = regions.map((NavigationRegion value) => value.toJson()).
toList(); | |
3018 result["targets"] = targets.map((NavigationTarget value) => value.toJson()).
toList(); | |
3019 result["files"] = files; | |
3020 return result; | |
3021 } | |
3022 | |
3023 Notification toNotification() { | |
3024 return new Notification("analysis.navigation", toJson()); | |
3025 } | |
3026 | |
3027 @override | |
3028 String toString() => JSON.encode(toJson()); | |
3029 | |
3030 @override | |
3031 bool operator==(other) { | |
3032 if (other is AnalysisNavigationParams) { | |
3033 return file == other.file && | |
3034 _listEqual(regions, other.regions, (NavigationRegion a, NavigationRegi
on b) => a == b) && | |
3035 _listEqual(targets, other.targets, (NavigationTarget a, NavigationTarg
et b) => a == b) && | |
3036 _listEqual(files, other.files, (String a, String b) => a == b); | |
3037 } | |
3038 return false; | |
3039 } | |
3040 | |
3041 @override | |
3042 int get hashCode { | |
3043 int hash = 0; | |
3044 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
3045 hash = _JenkinsSmiHash.combine(hash, regions.hashCode); | |
3046 hash = _JenkinsSmiHash.combine(hash, targets.hashCode); | |
3047 hash = _JenkinsSmiHash.combine(hash, files.hashCode); | |
3048 return _JenkinsSmiHash.finish(hash); | |
3049 } | |
3050 } | |
3051 | |
3052 /** | |
3053 * analysis.occurrences params | |
3054 * | |
3055 * { | |
3056 * "file": FilePath | |
3057 * "occurrences": List<Occurrences> | |
3058 * } | |
3059 */ | |
3060 class AnalysisOccurrencesParams implements HasToJson { | |
3061 String _file; | |
3062 | |
3063 List<Occurrences> _occurrences; | |
3064 | |
3065 /** | |
3066 * The file in which the references occur. | |
3067 */ | |
3068 String get file => _file; | |
3069 | |
3070 /** | |
3071 * The file in which the references occur. | |
3072 */ | |
3073 void set file(String value) { | |
3074 assert(value != null); | |
3075 this._file = value; | |
3076 } | |
3077 | |
3078 /** | |
3079 * The occurrences of references to elements within the file. | |
3080 */ | |
3081 List<Occurrences> get occurrences => _occurrences; | |
3082 | |
3083 /** | |
3084 * The occurrences of references to elements within the file. | |
3085 */ | |
3086 void set occurrences(List<Occurrences> value) { | |
3087 assert(value != null); | |
3088 this._occurrences = value; | |
3089 } | |
3090 | |
3091 AnalysisOccurrencesParams(String file, List<Occurrences> occurrences) { | |
3092 this.file = file; | |
3093 this.occurrences = occurrences; | |
3094 } | |
3095 | |
3096 factory AnalysisOccurrencesParams.fromJson(JsonDecoder jsonDecoder, String jso
nPath, Object json) { | |
3097 if (json == null) { | |
3098 json = {}; | |
3099 } | |
3100 if (json is Map) { | |
3101 String file; | |
3102 if (json.containsKey("file")) { | |
3103 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
3104 } else { | |
3105 throw jsonDecoder.missingKey(jsonPath, "file"); | |
3106 } | |
3107 List<Occurrences> occurrences; | |
3108 if (json.containsKey("occurrences")) { | |
3109 occurrences = jsonDecoder._decodeList(jsonPath + ".occurrences", json["o
ccurrences"], (String jsonPath, Object json) => new Occurrences.fromJson(jsonDec
oder, jsonPath, json)); | |
3110 } else { | |
3111 throw jsonDecoder.missingKey(jsonPath, "occurrences"); | |
3112 } | |
3113 return new AnalysisOccurrencesParams(file, occurrences); | |
3114 } else { | |
3115 throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params", json); | |
3116 } | |
3117 } | |
3118 | |
3119 factory AnalysisOccurrencesParams.fromNotification(Notification notification)
{ | |
3120 return new AnalysisOccurrencesParams.fromJson( | |
3121 new ResponseDecoder(null), "params", notification._params); | |
3122 } | |
3123 | |
3124 Map<String, dynamic> toJson() { | |
3125 Map<String, dynamic> result = {}; | |
3126 result["file"] = file; | |
3127 result["occurrences"] = occurrences.map((Occurrences value) => value.toJson(
)).toList(); | |
3128 return result; | |
3129 } | |
3130 | |
3131 Notification toNotification() { | |
3132 return new Notification("analysis.occurrences", toJson()); | |
3133 } | |
3134 | |
3135 @override | |
3136 String toString() => JSON.encode(toJson()); | |
3137 | |
3138 @override | |
3139 bool operator==(other) { | |
3140 if (other is AnalysisOccurrencesParams) { | |
3141 return file == other.file && | |
3142 _listEqual(occurrences, other.occurrences, (Occurrences a, Occurrences
b) => a == b); | |
3143 } | |
3144 return false; | |
3145 } | |
3146 | |
3147 @override | |
3148 int get hashCode { | |
3149 int hash = 0; | |
3150 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
3151 hash = _JenkinsSmiHash.combine(hash, occurrences.hashCode); | |
3152 return _JenkinsSmiHash.finish(hash); | |
3153 } | |
3154 } | |
3155 | |
3156 /** | |
3157 * analysis.outline params | |
3158 * | |
3159 * { | |
3160 * "file": FilePath | |
3161 * "kind": FileKind | |
3162 * "libraryName": optional String | |
3163 * "outline": Outline | |
3164 * } | |
3165 */ | |
3166 class AnalysisOutlineParams implements HasToJson { | |
3167 String _file; | |
3168 | |
3169 FileKind _kind; | |
3170 | |
3171 String _libraryName; | |
3172 | |
3173 Outline _outline; | |
3174 | |
3175 /** | |
3176 * The file with which the outline is associated. | |
3177 */ | |
3178 String get file => _file; | |
3179 | |
3180 /** | |
3181 * The file with which the outline is associated. | |
3182 */ | |
3183 void set file(String value) { | |
3184 assert(value != null); | |
3185 this._file = value; | |
3186 } | |
3187 | |
3188 /** | |
3189 * The kind of the file. | |
3190 */ | |
3191 FileKind get kind => _kind; | |
3192 | |
3193 /** | |
3194 * The kind of the file. | |
3195 */ | |
3196 void set kind(FileKind value) { | |
3197 assert(value != null); | |
3198 this._kind = value; | |
3199 } | |
3200 | |
3201 /** | |
3202 * The name of the library defined by the file using a "library" directive, | |
3203 * or referenced by a "part of" directive. If both "library" and "part of" | |
3204 * directives are present, then the "library" directive takes precedence. | |
3205 * This field will be omitted if the file has neither "library" nor "part of" | |
3206 * directives. | |
3207 */ | |
3208 String get libraryName => _libraryName; | |
3209 | |
3210 /** | |
3211 * The name of the library defined by the file using a "library" directive, | |
3212 * or referenced by a "part of" directive. If both "library" and "part of" | |
3213 * directives are present, then the "library" directive takes precedence. | |
3214 * This field will be omitted if the file has neither "library" nor "part of" | |
3215 * directives. | |
3216 */ | |
3217 void set libraryName(String value) { | |
3218 this._libraryName = value; | |
3219 } | |
3220 | |
3221 /** | |
3222 * The outline associated with the file. | |
3223 */ | |
3224 Outline get outline => _outline; | |
3225 | |
3226 /** | |
3227 * The outline associated with the file. | |
3228 */ | |
3229 void set outline(Outline value) { | |
3230 assert(value != null); | |
3231 this._outline = value; | |
3232 } | |
3233 | |
3234 AnalysisOutlineParams(String file, FileKind kind, Outline outline, {String lib
raryName}) { | |
3235 this.file = file; | |
3236 this.kind = kind; | |
3237 this.libraryName = libraryName; | |
3238 this.outline = outline; | |
3239 } | |
3240 | |
3241 factory AnalysisOutlineParams.fromJson(JsonDecoder jsonDecoder, String jsonPat
h, Object json) { | |
3242 if (json == null) { | |
3243 json = {}; | |
3244 } | |
3245 if (json is Map) { | |
3246 String file; | |
3247 if (json.containsKey("file")) { | |
3248 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
3249 } else { | |
3250 throw jsonDecoder.missingKey(jsonPath, "file"); | |
3251 } | |
3252 FileKind kind; | |
3253 if (json.containsKey("kind")) { | |
3254 kind = new FileKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind
"]); | |
3255 } else { | |
3256 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
3257 } | |
3258 String libraryName; | |
3259 if (json.containsKey("libraryName")) { | |
3260 libraryName = jsonDecoder._decodeString(jsonPath + ".libraryName", json[
"libraryName"]); | |
3261 } | |
3262 Outline outline; | |
3263 if (json.containsKey("outline")) { | |
3264 outline = new Outline.fromJson(jsonDecoder, jsonPath + ".outline", json[
"outline"]); | |
3265 } else { | |
3266 throw jsonDecoder.missingKey(jsonPath, "outline"); | |
3267 } | |
3268 return new AnalysisOutlineParams(file, kind, outline, libraryName: library
Name); | |
3269 } else { | |
3270 throw jsonDecoder.mismatch(jsonPath, "analysis.outline params", json); | |
3271 } | |
3272 } | |
3273 | |
3274 factory AnalysisOutlineParams.fromNotification(Notification notification) { | |
3275 return new AnalysisOutlineParams.fromJson( | |
3276 new ResponseDecoder(null), "params", notification._params); | |
3277 } | |
3278 | |
3279 Map<String, dynamic> toJson() { | |
3280 Map<String, dynamic> result = {}; | |
3281 result["file"] = file; | |
3282 result["kind"] = kind.toJson(); | |
3283 if (libraryName != null) { | |
3284 result["libraryName"] = libraryName; | |
3285 } | |
3286 result["outline"] = outline.toJson(); | |
3287 return result; | |
3288 } | |
3289 | |
3290 Notification toNotification() { | |
3291 return new Notification("analysis.outline", toJson()); | |
3292 } | |
3293 | |
3294 @override | |
3295 String toString() => JSON.encode(toJson()); | |
3296 | |
3297 @override | |
3298 bool operator==(other) { | |
3299 if (other is AnalysisOutlineParams) { | |
3300 return file == other.file && | |
3301 kind == other.kind && | |
3302 libraryName == other.libraryName && | |
3303 outline == other.outline; | |
3304 } | |
3305 return false; | |
3306 } | |
3307 | |
3308 @override | |
3309 int get hashCode { | |
3310 int hash = 0; | |
3311 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
3312 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
3313 hash = _JenkinsSmiHash.combine(hash, libraryName.hashCode); | |
3314 hash = _JenkinsSmiHash.combine(hash, outline.hashCode); | |
3315 return _JenkinsSmiHash.finish(hash); | |
3316 } | |
3317 } | |
3318 | |
3319 /** | |
3320 * analysis.overrides params | |
3321 * | |
3322 * { | |
3323 * "file": FilePath | |
3324 * "overrides": List<Override> | |
3325 * } | |
3326 */ | |
3327 class AnalysisOverridesParams implements HasToJson { | |
3328 String _file; | |
3329 | |
3330 List<Override> _overrides; | |
3331 | |
3332 /** | |
3333 * The file with which the overrides are associated. | |
3334 */ | |
3335 String get file => _file; | |
3336 | |
3337 /** | |
3338 * The file with which the overrides are associated. | |
3339 */ | |
3340 void set file(String value) { | |
3341 assert(value != null); | |
3342 this._file = value; | |
3343 } | |
3344 | |
3345 /** | |
3346 * The overrides associated with the file. | |
3347 */ | |
3348 List<Override> get overrides => _overrides; | |
3349 | |
3350 /** | |
3351 * The overrides associated with the file. | |
3352 */ | |
3353 void set overrides(List<Override> value) { | |
3354 assert(value != null); | |
3355 this._overrides = value; | |
3356 } | |
3357 | |
3358 AnalysisOverridesParams(String file, List<Override> overrides) { | |
3359 this.file = file; | |
3360 this.overrides = overrides; | |
3361 } | |
3362 | |
3363 factory AnalysisOverridesParams.fromJson(JsonDecoder jsonDecoder, String jsonP
ath, Object json) { | |
3364 if (json == null) { | |
3365 json = {}; | |
3366 } | |
3367 if (json is Map) { | |
3368 String file; | |
3369 if (json.containsKey("file")) { | |
3370 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
3371 } else { | |
3372 throw jsonDecoder.missingKey(jsonPath, "file"); | |
3373 } | |
3374 List<Override> overrides; | |
3375 if (json.containsKey("overrides")) { | |
3376 overrides = jsonDecoder._decodeList(jsonPath + ".overrides", json["overr
ides"], (String jsonPath, Object json) => new Override.fromJson(jsonDecoder, jso
nPath, json)); | |
3377 } else { | |
3378 throw jsonDecoder.missingKey(jsonPath, "overrides"); | |
3379 } | |
3380 return new AnalysisOverridesParams(file, overrides); | |
3381 } else { | |
3382 throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params", json); | |
3383 } | |
3384 } | |
3385 | |
3386 factory AnalysisOverridesParams.fromNotification(Notification notification) { | |
3387 return new AnalysisOverridesParams.fromJson( | |
3388 new ResponseDecoder(null), "params", notification._params); | |
3389 } | |
3390 | |
3391 Map<String, dynamic> toJson() { | |
3392 Map<String, dynamic> result = {}; | |
3393 result["file"] = file; | |
3394 result["overrides"] = overrides.map((Override value) => value.toJson()).toLi
st(); | |
3395 return result; | |
3396 } | |
3397 | |
3398 Notification toNotification() { | |
3399 return new Notification("analysis.overrides", toJson()); | |
3400 } | |
3401 | |
3402 @override | |
3403 String toString() => JSON.encode(toJson()); | |
3404 | |
3405 @override | |
3406 bool operator==(other) { | |
3407 if (other is AnalysisOverridesParams) { | |
3408 return file == other.file && | |
3409 _listEqual(overrides, other.overrides, (Override a, Override b) => a =
= b); | |
3410 } | |
3411 return false; | |
3412 } | |
3413 | |
3414 @override | |
3415 int get hashCode { | |
3416 int hash = 0; | |
3417 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
3418 hash = _JenkinsSmiHash.combine(hash, overrides.hashCode); | |
3419 return _JenkinsSmiHash.finish(hash); | |
3420 } | |
3421 } | |
3422 | |
3423 /** | |
3424 * completion.getSuggestions params | |
3425 * | |
3426 * { | |
3427 * "file": FilePath | |
3428 * "offset": int | |
3429 * } | |
3430 */ | |
3431 class CompletionGetSuggestionsParams implements HasToJson { | |
3432 String _file; | |
3433 | |
3434 int _offset; | |
3435 | |
3436 /** | |
3437 * The file containing the point at which suggestions are to be made. | |
3438 */ | |
3439 String get file => _file; | |
3440 | |
3441 /** | |
3442 * The file containing the point at which suggestions are to be made. | |
3443 */ | |
3444 void set file(String value) { | |
3445 assert(value != null); | |
3446 this._file = value; | |
3447 } | |
3448 | |
3449 /** | |
3450 * The offset within the file at which suggestions are to be made. | |
3451 */ | |
3452 int get offset => _offset; | |
3453 | |
3454 /** | |
3455 * The offset within the file at which suggestions are to be made. | |
3456 */ | |
3457 void set offset(int value) { | |
3458 assert(value != null); | |
3459 this._offset = value; | |
3460 } | |
3461 | |
3462 CompletionGetSuggestionsParams(String file, int offset) { | |
3463 this.file = file; | |
3464 this.offset = offset; | |
3465 } | |
3466 | |
3467 factory CompletionGetSuggestionsParams.fromJson(JsonDecoder jsonDecoder, Strin
g jsonPath, Object json) { | |
3468 if (json == null) { | |
3469 json = {}; | |
3470 } | |
3471 if (json is Map) { | |
3472 String file; | |
3473 if (json.containsKey("file")) { | |
3474 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
3475 } else { | |
3476 throw jsonDecoder.missingKey(jsonPath, "file"); | |
3477 } | |
3478 int offset; | |
3479 if (json.containsKey("offset")) { | |
3480 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
3481 } else { | |
3482 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
3483 } | |
3484 return new CompletionGetSuggestionsParams(file, offset); | |
3485 } else { | |
3486 throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions params", j
son); | |
3487 } | |
3488 } | |
3489 | |
3490 factory CompletionGetSuggestionsParams.fromRequest(Request request) { | |
3491 return new CompletionGetSuggestionsParams.fromJson( | |
3492 new RequestDecoder(request), "params", request._params); | |
3493 } | |
3494 | |
3495 Map<String, dynamic> toJson() { | |
3496 Map<String, dynamic> result = {}; | |
3497 result["file"] = file; | |
3498 result["offset"] = offset; | |
3499 return result; | |
3500 } | |
3501 | |
3502 Request toRequest(String id) { | |
3503 return new Request(id, "completion.getSuggestions", toJson()); | |
3504 } | |
3505 | |
3506 @override | |
3507 String toString() => JSON.encode(toJson()); | |
3508 | |
3509 @override | |
3510 bool operator==(other) { | |
3511 if (other is CompletionGetSuggestionsParams) { | |
3512 return file == other.file && | |
3513 offset == other.offset; | |
3514 } | |
3515 return false; | |
3516 } | |
3517 | |
3518 @override | |
3519 int get hashCode { | |
3520 int hash = 0; | |
3521 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
3522 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
3523 return _JenkinsSmiHash.finish(hash); | |
3524 } | |
3525 } | |
3526 | |
3527 /** | |
3528 * completion.getSuggestions result | |
3529 * | |
3530 * { | |
3531 * "id": CompletionId | |
3532 * } | |
3533 */ | |
3534 class CompletionGetSuggestionsResult implements HasToJson { | |
3535 String _id; | |
3536 | |
3537 /** | |
3538 * The identifier used to associate results with this completion request. | |
3539 */ | |
3540 String get id => _id; | |
3541 | |
3542 /** | |
3543 * The identifier used to associate results with this completion request. | |
3544 */ | |
3545 void set id(String value) { | |
3546 assert(value != null); | |
3547 this._id = value; | |
3548 } | |
3549 | |
3550 CompletionGetSuggestionsResult(String id) { | |
3551 this.id = id; | |
3552 } | |
3553 | |
3554 factory CompletionGetSuggestionsResult.fromJson(JsonDecoder jsonDecoder, Strin
g jsonPath, Object json) { | |
3555 if (json == null) { | |
3556 json = {}; | |
3557 } | |
3558 if (json is Map) { | |
3559 String id; | |
3560 if (json.containsKey("id")) { | |
3561 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
3562 } else { | |
3563 throw jsonDecoder.missingKey(jsonPath, "id"); | |
3564 } | |
3565 return new CompletionGetSuggestionsResult(id); | |
3566 } else { | |
3567 throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions result", j
son); | |
3568 } | |
3569 } | |
3570 | |
3571 factory CompletionGetSuggestionsResult.fromResponse(Response response) { | |
3572 return new CompletionGetSuggestionsResult.fromJson( | |
3573 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
3574 } | |
3575 | |
3576 Map<String, dynamic> toJson() { | |
3577 Map<String, dynamic> result = {}; | |
3578 result["id"] = id; | |
3579 return result; | |
3580 } | |
3581 | |
3582 Response toResponse(String id) { | |
3583 return new Response(id, result: toJson()); | |
3584 } | |
3585 | |
3586 @override | |
3587 String toString() => JSON.encode(toJson()); | |
3588 | |
3589 @override | |
3590 bool operator==(other) { | |
3591 if (other is CompletionGetSuggestionsResult) { | |
3592 return id == other.id; | |
3593 } | |
3594 return false; | |
3595 } | |
3596 | |
3597 @override | |
3598 int get hashCode { | |
3599 int hash = 0; | |
3600 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
3601 return _JenkinsSmiHash.finish(hash); | |
3602 } | |
3603 } | |
3604 | |
3605 /** | |
3606 * completion.results params | |
3607 * | |
3608 * { | |
3609 * "id": CompletionId | |
3610 * "replacementOffset": int | |
3611 * "replacementLength": int | |
3612 * "results": List<CompletionSuggestion> | |
3613 * "isLast": bool | |
3614 * } | |
3615 */ | |
3616 class CompletionResultsParams implements HasToJson { | |
3617 String _id; | |
3618 | |
3619 int _replacementOffset; | |
3620 | |
3621 int _replacementLength; | |
3622 | |
3623 List<CompletionSuggestion> _results; | |
3624 | |
3625 bool _isLast; | |
3626 | |
3627 /** | |
3628 * The id associated with the completion. | |
3629 */ | |
3630 String get id => _id; | |
3631 | |
3632 /** | |
3633 * The id associated with the completion. | |
3634 */ | |
3635 void set id(String value) { | |
3636 assert(value != null); | |
3637 this._id = value; | |
3638 } | |
3639 | |
3640 /** | |
3641 * The offset of the start of the text to be replaced. This will be different | |
3642 * than the offset used to request the completion suggestions if there was a | |
3643 * portion of an identifier before the original offset. In particular, the | |
3644 * replacementOffset will be the offset of the beginning of said identifier. | |
3645 */ | |
3646 int get replacementOffset => _replacementOffset; | |
3647 | |
3648 /** | |
3649 * The offset of the start of the text to be replaced. This will be different | |
3650 * than the offset used to request the completion suggestions if there was a | |
3651 * portion of an identifier before the original offset. In particular, the | |
3652 * replacementOffset will be the offset of the beginning of said identifier. | |
3653 */ | |
3654 void set replacementOffset(int value) { | |
3655 assert(value != null); | |
3656 this._replacementOffset = value; | |
3657 } | |
3658 | |
3659 /** | |
3660 * The length of the text to be replaced if the remainder of the identifier | |
3661 * containing the cursor is to be replaced when the suggestion is applied | |
3662 * (that is, the number of characters in the existing identifier). | |
3663 */ | |
3664 int get replacementLength => _replacementLength; | |
3665 | |
3666 /** | |
3667 * The length of the text to be replaced if the remainder of the identifier | |
3668 * containing the cursor is to be replaced when the suggestion is applied | |
3669 * (that is, the number of characters in the existing identifier). | |
3670 */ | |
3671 void set replacementLength(int value) { | |
3672 assert(value != null); | |
3673 this._replacementLength = value; | |
3674 } | |
3675 | |
3676 /** | |
3677 * The completion suggestions being reported. The notification contains all | |
3678 * possible completions at the requested cursor position, even those that do | |
3679 * not match the characters the user has already typed. This allows the | |
3680 * client to respond to further keystrokes from the user without having to | |
3681 * make additional requests. | |
3682 */ | |
3683 List<CompletionSuggestion> get results => _results; | |
3684 | |
3685 /** | |
3686 * The completion suggestions being reported. The notification contains all | |
3687 * possible completions at the requested cursor position, even those that do | |
3688 * not match the characters the user has already typed. This allows the | |
3689 * client to respond to further keystrokes from the user without having to | |
3690 * make additional requests. | |
3691 */ | |
3692 void set results(List<CompletionSuggestion> value) { | |
3693 assert(value != null); | |
3694 this._results = value; | |
3695 } | |
3696 | |
3697 /** | |
3698 * True if this is that last set of results that will be returned for the | |
3699 * indicated completion. | |
3700 */ | |
3701 bool get isLast => _isLast; | |
3702 | |
3703 /** | |
3704 * True if this is that last set of results that will be returned for the | |
3705 * indicated completion. | |
3706 */ | |
3707 void set isLast(bool value) { | |
3708 assert(value != null); | |
3709 this._isLast = value; | |
3710 } | |
3711 | |
3712 CompletionResultsParams(String id, int replacementOffset, int replacementLengt
h, List<CompletionSuggestion> results, bool isLast) { | |
3713 this.id = id; | |
3714 this.replacementOffset = replacementOffset; | |
3715 this.replacementLength = replacementLength; | |
3716 this.results = results; | |
3717 this.isLast = isLast; | |
3718 } | |
3719 | |
3720 factory CompletionResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonP
ath, Object json) { | |
3721 if (json == null) { | |
3722 json = {}; | |
3723 } | |
3724 if (json is Map) { | |
3725 String id; | |
3726 if (json.containsKey("id")) { | |
3727 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
3728 } else { | |
3729 throw jsonDecoder.missingKey(jsonPath, "id"); | |
3730 } | |
3731 int replacementOffset; | |
3732 if (json.containsKey("replacementOffset")) { | |
3733 replacementOffset = jsonDecoder._decodeInt(jsonPath + ".replacementOffse
t", json["replacementOffset"]); | |
3734 } else { | |
3735 throw jsonDecoder.missingKey(jsonPath, "replacementOffset"); | |
3736 } | |
3737 int replacementLength; | |
3738 if (json.containsKey("replacementLength")) { | |
3739 replacementLength = jsonDecoder._decodeInt(jsonPath + ".replacementLengt
h", json["replacementLength"]); | |
3740 } else { | |
3741 throw jsonDecoder.missingKey(jsonPath, "replacementLength"); | |
3742 } | |
3743 List<CompletionSuggestion> results; | |
3744 if (json.containsKey("results")) { | |
3745 results = jsonDecoder._decodeList(jsonPath + ".results", json["results"]
, (String jsonPath, Object json) => new CompletionSuggestion.fromJson(jsonDecode
r, jsonPath, json)); | |
3746 } else { | |
3747 throw jsonDecoder.missingKey(jsonPath, "results"); | |
3748 } | |
3749 bool isLast; | |
3750 if (json.containsKey("isLast")) { | |
3751 isLast = jsonDecoder._decodeBool(jsonPath + ".isLast", json["isLast"]); | |
3752 } else { | |
3753 throw jsonDecoder.missingKey(jsonPath, "isLast"); | |
3754 } | |
3755 return new CompletionResultsParams(id, replacementOffset, replacementLengt
h, results, isLast); | |
3756 } else { | |
3757 throw jsonDecoder.mismatch(jsonPath, "completion.results params", json); | |
3758 } | |
3759 } | |
3760 | |
3761 factory CompletionResultsParams.fromNotification(Notification notification) { | |
3762 return new CompletionResultsParams.fromJson( | |
3763 new ResponseDecoder(null), "params", notification._params); | |
3764 } | |
3765 | |
3766 Map<String, dynamic> toJson() { | |
3767 Map<String, dynamic> result = {}; | |
3768 result["id"] = id; | |
3769 result["replacementOffset"] = replacementOffset; | |
3770 result["replacementLength"] = replacementLength; | |
3771 result["results"] = results.map((CompletionSuggestion value) => value.toJson
()).toList(); | |
3772 result["isLast"] = isLast; | |
3773 return result; | |
3774 } | |
3775 | |
3776 Notification toNotification() { | |
3777 return new Notification("completion.results", toJson()); | |
3778 } | |
3779 | |
3780 @override | |
3781 String toString() => JSON.encode(toJson()); | |
3782 | |
3783 @override | |
3784 bool operator==(other) { | |
3785 if (other is CompletionResultsParams) { | |
3786 return id == other.id && | |
3787 replacementOffset == other.replacementOffset && | |
3788 replacementLength == other.replacementLength && | |
3789 _listEqual(results, other.results, (CompletionSuggestion a, Completion
Suggestion b) => a == b) && | |
3790 isLast == other.isLast; | |
3791 } | |
3792 return false; | |
3793 } | |
3794 | |
3795 @override | |
3796 int get hashCode { | |
3797 int hash = 0; | |
3798 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
3799 hash = _JenkinsSmiHash.combine(hash, replacementOffset.hashCode); | |
3800 hash = _JenkinsSmiHash.combine(hash, replacementLength.hashCode); | |
3801 hash = _JenkinsSmiHash.combine(hash, results.hashCode); | |
3802 hash = _JenkinsSmiHash.combine(hash, isLast.hashCode); | |
3803 return _JenkinsSmiHash.finish(hash); | |
3804 } | |
3805 } | |
3806 | |
3807 /** | |
3808 * search.findElementReferences params | |
3809 * | |
3810 * { | |
3811 * "file": FilePath | |
3812 * "offset": int | |
3813 * "includePotential": bool | |
3814 * } | |
3815 */ | |
3816 class SearchFindElementReferencesParams implements HasToJson { | |
3817 String _file; | |
3818 | |
3819 int _offset; | |
3820 | |
3821 bool _includePotential; | |
3822 | |
3823 /** | |
3824 * The file containing the declaration of or reference to the element used to | |
3825 * define the search. | |
3826 */ | |
3827 String get file => _file; | |
3828 | |
3829 /** | |
3830 * The file containing the declaration of or reference to the element used to | |
3831 * define the search. | |
3832 */ | |
3833 void set file(String value) { | |
3834 assert(value != null); | |
3835 this._file = value; | |
3836 } | |
3837 | |
3838 /** | |
3839 * The offset within the file of the declaration of or reference to the | |
3840 * element. | |
3841 */ | |
3842 int get offset => _offset; | |
3843 | |
3844 /** | |
3845 * The offset within the file of the declaration of or reference to the | |
3846 * element. | |
3847 */ | |
3848 void set offset(int value) { | |
3849 assert(value != null); | |
3850 this._offset = value; | |
3851 } | |
3852 | |
3853 /** | |
3854 * True if potential matches are to be included in the results. | |
3855 */ | |
3856 bool get includePotential => _includePotential; | |
3857 | |
3858 /** | |
3859 * True if potential matches are to be included in the results. | |
3860 */ | |
3861 void set includePotential(bool value) { | |
3862 assert(value != null); | |
3863 this._includePotential = value; | |
3864 } | |
3865 | |
3866 SearchFindElementReferencesParams(String file, int offset, bool includePotenti
al) { | |
3867 this.file = file; | |
3868 this.offset = offset; | |
3869 this.includePotential = includePotential; | |
3870 } | |
3871 | |
3872 factory SearchFindElementReferencesParams.fromJson(JsonDecoder jsonDecoder, St
ring jsonPath, Object json) { | |
3873 if (json == null) { | |
3874 json = {}; | |
3875 } | |
3876 if (json is Map) { | |
3877 String file; | |
3878 if (json.containsKey("file")) { | |
3879 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
3880 } else { | |
3881 throw jsonDecoder.missingKey(jsonPath, "file"); | |
3882 } | |
3883 int offset; | |
3884 if (json.containsKey("offset")) { | |
3885 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
3886 } else { | |
3887 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
3888 } | |
3889 bool includePotential; | |
3890 if (json.containsKey("includePotential")) { | |
3891 includePotential = jsonDecoder._decodeBool(jsonPath + ".includePotential
", json["includePotential"]); | |
3892 } else { | |
3893 throw jsonDecoder.missingKey(jsonPath, "includePotential"); | |
3894 } | |
3895 return new SearchFindElementReferencesParams(file, offset, includePotentia
l); | |
3896 } else { | |
3897 throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences params"
, json); | |
3898 } | |
3899 } | |
3900 | |
3901 factory SearchFindElementReferencesParams.fromRequest(Request request) { | |
3902 return new SearchFindElementReferencesParams.fromJson( | |
3903 new RequestDecoder(request), "params", request._params); | |
3904 } | |
3905 | |
3906 Map<String, dynamic> toJson() { | |
3907 Map<String, dynamic> result = {}; | |
3908 result["file"] = file; | |
3909 result["offset"] = offset; | |
3910 result["includePotential"] = includePotential; | |
3911 return result; | |
3912 } | |
3913 | |
3914 Request toRequest(String id) { | |
3915 return new Request(id, "search.findElementReferences", toJson()); | |
3916 } | |
3917 | |
3918 @override | |
3919 String toString() => JSON.encode(toJson()); | |
3920 | |
3921 @override | |
3922 bool operator==(other) { | |
3923 if (other is SearchFindElementReferencesParams) { | |
3924 return file == other.file && | |
3925 offset == other.offset && | |
3926 includePotential == other.includePotential; | |
3927 } | |
3928 return false; | |
3929 } | |
3930 | |
3931 @override | |
3932 int get hashCode { | |
3933 int hash = 0; | |
3934 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
3935 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
3936 hash = _JenkinsSmiHash.combine(hash, includePotential.hashCode); | |
3937 return _JenkinsSmiHash.finish(hash); | |
3938 } | |
3939 } | |
3940 | |
3941 /** | |
3942 * search.findElementReferences result | |
3943 * | |
3944 * { | |
3945 * "id": optional SearchId | |
3946 * "element": optional Element | |
3947 * } | |
3948 */ | |
3949 class SearchFindElementReferencesResult implements HasToJson { | |
3950 String _id; | |
3951 | |
3952 Element _element; | |
3953 | |
3954 /** | |
3955 * The identifier used to associate results with this search request. | |
3956 * | |
3957 * If no element was found at the given location, this field will be absent, | |
3958 * and no results will be reported via the search.results notification. | |
3959 */ | |
3960 String get id => _id; | |
3961 | |
3962 /** | |
3963 * The identifier used to associate results with this search request. | |
3964 * | |
3965 * If no element was found at the given location, this field will be absent, | |
3966 * and no results will be reported via the search.results notification. | |
3967 */ | |
3968 void set id(String value) { | |
3969 this._id = value; | |
3970 } | |
3971 | |
3972 /** | |
3973 * The element referenced or defined at the given offset and whose references | |
3974 * will be returned in the search results. | |
3975 * | |
3976 * If no element was found at the given location, this field will be absent. | |
3977 */ | |
3978 Element get element => _element; | |
3979 | |
3980 /** | |
3981 * The element referenced or defined at the given offset and whose references | |
3982 * will be returned in the search results. | |
3983 * | |
3984 * If no element was found at the given location, this field will be absent. | |
3985 */ | |
3986 void set element(Element value) { | |
3987 this._element = value; | |
3988 } | |
3989 | |
3990 SearchFindElementReferencesResult({String id, Element element}) { | |
3991 this.id = id; | |
3992 this.element = element; | |
3993 } | |
3994 | |
3995 factory SearchFindElementReferencesResult.fromJson(JsonDecoder jsonDecoder, St
ring jsonPath, Object json) { | |
3996 if (json == null) { | |
3997 json = {}; | |
3998 } | |
3999 if (json is Map) { | |
4000 String id; | |
4001 if (json.containsKey("id")) { | |
4002 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
4003 } | |
4004 Element element; | |
4005 if (json.containsKey("element")) { | |
4006 element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json[
"element"]); | |
4007 } | |
4008 return new SearchFindElementReferencesResult(id: id, element: element); | |
4009 } else { | |
4010 throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences result"
, json); | |
4011 } | |
4012 } | |
4013 | |
4014 factory SearchFindElementReferencesResult.fromResponse(Response response) { | |
4015 return new SearchFindElementReferencesResult.fromJson( | |
4016 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
4017 } | |
4018 | |
4019 Map<String, dynamic> toJson() { | |
4020 Map<String, dynamic> result = {}; | |
4021 if (id != null) { | |
4022 result["id"] = id; | |
4023 } | |
4024 if (element != null) { | |
4025 result["element"] = element.toJson(); | |
4026 } | |
4027 return result; | |
4028 } | |
4029 | |
4030 Response toResponse(String id) { | |
4031 return new Response(id, result: toJson()); | |
4032 } | |
4033 | |
4034 @override | |
4035 String toString() => JSON.encode(toJson()); | |
4036 | |
4037 @override | |
4038 bool operator==(other) { | |
4039 if (other is SearchFindElementReferencesResult) { | |
4040 return id == other.id && | |
4041 element == other.element; | |
4042 } | |
4043 return false; | |
4044 } | |
4045 | |
4046 @override | |
4047 int get hashCode { | |
4048 int hash = 0; | |
4049 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
4050 hash = _JenkinsSmiHash.combine(hash, element.hashCode); | |
4051 return _JenkinsSmiHash.finish(hash); | |
4052 } | |
4053 } | |
4054 | |
4055 /** | |
4056 * search.findMemberDeclarations params | |
4057 * | |
4058 * { | |
4059 * "name": String | |
4060 * } | |
4061 */ | |
4062 class SearchFindMemberDeclarationsParams implements HasToJson { | |
4063 String _name; | |
4064 | |
4065 /** | |
4066 * The name of the declarations to be found. | |
4067 */ | |
4068 String get name => _name; | |
4069 | |
4070 /** | |
4071 * The name of the declarations to be found. | |
4072 */ | |
4073 void set name(String value) { | |
4074 assert(value != null); | |
4075 this._name = value; | |
4076 } | |
4077 | |
4078 SearchFindMemberDeclarationsParams(String name) { | |
4079 this.name = name; | |
4080 } | |
4081 | |
4082 factory SearchFindMemberDeclarationsParams.fromJson(JsonDecoder jsonDecoder, S
tring jsonPath, Object json) { | |
4083 if (json == null) { | |
4084 json = {}; | |
4085 } | |
4086 if (json is Map) { | |
4087 String name; | |
4088 if (json.containsKey("name")) { | |
4089 name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]); | |
4090 } else { | |
4091 throw jsonDecoder.missingKey(jsonPath, "name"); | |
4092 } | |
4093 return new SearchFindMemberDeclarationsParams(name); | |
4094 } else { | |
4095 throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations params
", json); | |
4096 } | |
4097 } | |
4098 | |
4099 factory SearchFindMemberDeclarationsParams.fromRequest(Request request) { | |
4100 return new SearchFindMemberDeclarationsParams.fromJson( | |
4101 new RequestDecoder(request), "params", request._params); | |
4102 } | |
4103 | |
4104 Map<String, dynamic> toJson() { | |
4105 Map<String, dynamic> result = {}; | |
4106 result["name"] = name; | |
4107 return result; | |
4108 } | |
4109 | |
4110 Request toRequest(String id) { | |
4111 return new Request(id, "search.findMemberDeclarations", toJson()); | |
4112 } | |
4113 | |
4114 @override | |
4115 String toString() => JSON.encode(toJson()); | |
4116 | |
4117 @override | |
4118 bool operator==(other) { | |
4119 if (other is SearchFindMemberDeclarationsParams) { | |
4120 return name == other.name; | |
4121 } | |
4122 return false; | |
4123 } | |
4124 | |
4125 @override | |
4126 int get hashCode { | |
4127 int hash = 0; | |
4128 hash = _JenkinsSmiHash.combine(hash, name.hashCode); | |
4129 return _JenkinsSmiHash.finish(hash); | |
4130 } | |
4131 } | |
4132 | |
4133 /** | |
4134 * search.findMemberDeclarations result | |
4135 * | |
4136 * { | |
4137 * "id": SearchId | |
4138 * } | |
4139 */ | |
4140 class SearchFindMemberDeclarationsResult implements HasToJson { | |
4141 String _id; | |
4142 | |
4143 /** | |
4144 * The identifier used to associate results with this search request. | |
4145 */ | |
4146 String get id => _id; | |
4147 | |
4148 /** | |
4149 * The identifier used to associate results with this search request. | |
4150 */ | |
4151 void set id(String value) { | |
4152 assert(value != null); | |
4153 this._id = value; | |
4154 } | |
4155 | |
4156 SearchFindMemberDeclarationsResult(String id) { | |
4157 this.id = id; | |
4158 } | |
4159 | |
4160 factory SearchFindMemberDeclarationsResult.fromJson(JsonDecoder jsonDecoder, S
tring jsonPath, Object json) { | |
4161 if (json == null) { | |
4162 json = {}; | |
4163 } | |
4164 if (json is Map) { | |
4165 String id; | |
4166 if (json.containsKey("id")) { | |
4167 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
4168 } else { | |
4169 throw jsonDecoder.missingKey(jsonPath, "id"); | |
4170 } | |
4171 return new SearchFindMemberDeclarationsResult(id); | |
4172 } else { | |
4173 throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations result
", json); | |
4174 } | |
4175 } | |
4176 | |
4177 factory SearchFindMemberDeclarationsResult.fromResponse(Response response) { | |
4178 return new SearchFindMemberDeclarationsResult.fromJson( | |
4179 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
4180 } | |
4181 | |
4182 Map<String, dynamic> toJson() { | |
4183 Map<String, dynamic> result = {}; | |
4184 result["id"] = id; | |
4185 return result; | |
4186 } | |
4187 | |
4188 Response toResponse(String id) { | |
4189 return new Response(id, result: toJson()); | |
4190 } | |
4191 | |
4192 @override | |
4193 String toString() => JSON.encode(toJson()); | |
4194 | |
4195 @override | |
4196 bool operator==(other) { | |
4197 if (other is SearchFindMemberDeclarationsResult) { | |
4198 return id == other.id; | |
4199 } | |
4200 return false; | |
4201 } | |
4202 | |
4203 @override | |
4204 int get hashCode { | |
4205 int hash = 0; | |
4206 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
4207 return _JenkinsSmiHash.finish(hash); | |
4208 } | |
4209 } | |
4210 | |
4211 /** | |
4212 * search.findMemberReferences params | |
4213 * | |
4214 * { | |
4215 * "name": String | |
4216 * } | |
4217 */ | |
4218 class SearchFindMemberReferencesParams implements HasToJson { | |
4219 String _name; | |
4220 | |
4221 /** | |
4222 * The name of the references to be found. | |
4223 */ | |
4224 String get name => _name; | |
4225 | |
4226 /** | |
4227 * The name of the references to be found. | |
4228 */ | |
4229 void set name(String value) { | |
4230 assert(value != null); | |
4231 this._name = value; | |
4232 } | |
4233 | |
4234 SearchFindMemberReferencesParams(String name) { | |
4235 this.name = name; | |
4236 } | |
4237 | |
4238 factory SearchFindMemberReferencesParams.fromJson(JsonDecoder jsonDecoder, Str
ing jsonPath, Object json) { | |
4239 if (json == null) { | |
4240 json = {}; | |
4241 } | |
4242 if (json is Map) { | |
4243 String name; | |
4244 if (json.containsKey("name")) { | |
4245 name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]); | |
4246 } else { | |
4247 throw jsonDecoder.missingKey(jsonPath, "name"); | |
4248 } | |
4249 return new SearchFindMemberReferencesParams(name); | |
4250 } else { | |
4251 throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences params",
json); | |
4252 } | |
4253 } | |
4254 | |
4255 factory SearchFindMemberReferencesParams.fromRequest(Request request) { | |
4256 return new SearchFindMemberReferencesParams.fromJson( | |
4257 new RequestDecoder(request), "params", request._params); | |
4258 } | |
4259 | |
4260 Map<String, dynamic> toJson() { | |
4261 Map<String, dynamic> result = {}; | |
4262 result["name"] = name; | |
4263 return result; | |
4264 } | |
4265 | |
4266 Request toRequest(String id) { | |
4267 return new Request(id, "search.findMemberReferences", toJson()); | |
4268 } | |
4269 | |
4270 @override | |
4271 String toString() => JSON.encode(toJson()); | |
4272 | |
4273 @override | |
4274 bool operator==(other) { | |
4275 if (other is SearchFindMemberReferencesParams) { | |
4276 return name == other.name; | |
4277 } | |
4278 return false; | |
4279 } | |
4280 | |
4281 @override | |
4282 int get hashCode { | |
4283 int hash = 0; | |
4284 hash = _JenkinsSmiHash.combine(hash, name.hashCode); | |
4285 return _JenkinsSmiHash.finish(hash); | |
4286 } | |
4287 } | |
4288 | |
4289 /** | |
4290 * search.findMemberReferences result | |
4291 * | |
4292 * { | |
4293 * "id": SearchId | |
4294 * } | |
4295 */ | |
4296 class SearchFindMemberReferencesResult implements HasToJson { | |
4297 String _id; | |
4298 | |
4299 /** | |
4300 * The identifier used to associate results with this search request. | |
4301 */ | |
4302 String get id => _id; | |
4303 | |
4304 /** | |
4305 * The identifier used to associate results with this search request. | |
4306 */ | |
4307 void set id(String value) { | |
4308 assert(value != null); | |
4309 this._id = value; | |
4310 } | |
4311 | |
4312 SearchFindMemberReferencesResult(String id) { | |
4313 this.id = id; | |
4314 } | |
4315 | |
4316 factory SearchFindMemberReferencesResult.fromJson(JsonDecoder jsonDecoder, Str
ing jsonPath, Object json) { | |
4317 if (json == null) { | |
4318 json = {}; | |
4319 } | |
4320 if (json is Map) { | |
4321 String id; | |
4322 if (json.containsKey("id")) { | |
4323 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
4324 } else { | |
4325 throw jsonDecoder.missingKey(jsonPath, "id"); | |
4326 } | |
4327 return new SearchFindMemberReferencesResult(id); | |
4328 } else { | |
4329 throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences result",
json); | |
4330 } | |
4331 } | |
4332 | |
4333 factory SearchFindMemberReferencesResult.fromResponse(Response response) { | |
4334 return new SearchFindMemberReferencesResult.fromJson( | |
4335 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
4336 } | |
4337 | |
4338 Map<String, dynamic> toJson() { | |
4339 Map<String, dynamic> result = {}; | |
4340 result["id"] = id; | |
4341 return result; | |
4342 } | |
4343 | |
4344 Response toResponse(String id) { | |
4345 return new Response(id, result: toJson()); | |
4346 } | |
4347 | |
4348 @override | |
4349 String toString() => JSON.encode(toJson()); | |
4350 | |
4351 @override | |
4352 bool operator==(other) { | |
4353 if (other is SearchFindMemberReferencesResult) { | |
4354 return id == other.id; | |
4355 } | |
4356 return false; | |
4357 } | |
4358 | |
4359 @override | |
4360 int get hashCode { | |
4361 int hash = 0; | |
4362 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
4363 return _JenkinsSmiHash.finish(hash); | |
4364 } | |
4365 } | |
4366 | |
4367 /** | |
4368 * search.findTopLevelDeclarations params | |
4369 * | |
4370 * { | |
4371 * "pattern": String | |
4372 * } | |
4373 */ | |
4374 class SearchFindTopLevelDeclarationsParams implements HasToJson { | |
4375 String _pattern; | |
4376 | |
4377 /** | |
4378 * The regular expression used to match the names of the declarations to be | |
4379 * found. | |
4380 */ | |
4381 String get pattern => _pattern; | |
4382 | |
4383 /** | |
4384 * The regular expression used to match the names of the declarations to be | |
4385 * found. | |
4386 */ | |
4387 void set pattern(String value) { | |
4388 assert(value != null); | |
4389 this._pattern = value; | |
4390 } | |
4391 | |
4392 SearchFindTopLevelDeclarationsParams(String pattern) { | |
4393 this.pattern = pattern; | |
4394 } | |
4395 | |
4396 factory SearchFindTopLevelDeclarationsParams.fromJson(JsonDecoder jsonDecoder,
String jsonPath, Object json) { | |
4397 if (json == null) { | |
4398 json = {}; | |
4399 } | |
4400 if (json is Map) { | |
4401 String pattern; | |
4402 if (json.containsKey("pattern")) { | |
4403 pattern = jsonDecoder._decodeString(jsonPath + ".pattern", json["pattern
"]); | |
4404 } else { | |
4405 throw jsonDecoder.missingKey(jsonPath, "pattern"); | |
4406 } | |
4407 return new SearchFindTopLevelDeclarationsParams(pattern); | |
4408 } else { | |
4409 throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations para
ms", json); | |
4410 } | |
4411 } | |
4412 | |
4413 factory SearchFindTopLevelDeclarationsParams.fromRequest(Request request) { | |
4414 return new SearchFindTopLevelDeclarationsParams.fromJson( | |
4415 new RequestDecoder(request), "params", request._params); | |
4416 } | |
4417 | |
4418 Map<String, dynamic> toJson() { | |
4419 Map<String, dynamic> result = {}; | |
4420 result["pattern"] = pattern; | |
4421 return result; | |
4422 } | |
4423 | |
4424 Request toRequest(String id) { | |
4425 return new Request(id, "search.findTopLevelDeclarations", toJson()); | |
4426 } | |
4427 | |
4428 @override | |
4429 String toString() => JSON.encode(toJson()); | |
4430 | |
4431 @override | |
4432 bool operator==(other) { | |
4433 if (other is SearchFindTopLevelDeclarationsParams) { | |
4434 return pattern == other.pattern; | |
4435 } | |
4436 return false; | |
4437 } | |
4438 | |
4439 @override | |
4440 int get hashCode { | |
4441 int hash = 0; | |
4442 hash = _JenkinsSmiHash.combine(hash, pattern.hashCode); | |
4443 return _JenkinsSmiHash.finish(hash); | |
4444 } | |
4445 } | |
4446 | |
4447 /** | |
4448 * search.findTopLevelDeclarations result | |
4449 * | |
4450 * { | |
4451 * "id": SearchId | |
4452 * } | |
4453 */ | |
4454 class SearchFindTopLevelDeclarationsResult implements HasToJson { | |
4455 String _id; | |
4456 | |
4457 /** | |
4458 * The identifier used to associate results with this search request. | |
4459 */ | |
4460 String get id => _id; | |
4461 | |
4462 /** | |
4463 * The identifier used to associate results with this search request. | |
4464 */ | |
4465 void set id(String value) { | |
4466 assert(value != null); | |
4467 this._id = value; | |
4468 } | |
4469 | |
4470 SearchFindTopLevelDeclarationsResult(String id) { | |
4471 this.id = id; | |
4472 } | |
4473 | |
4474 factory SearchFindTopLevelDeclarationsResult.fromJson(JsonDecoder jsonDecoder,
String jsonPath, Object json) { | |
4475 if (json == null) { | |
4476 json = {}; | |
4477 } | |
4478 if (json is Map) { | |
4479 String id; | |
4480 if (json.containsKey("id")) { | |
4481 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
4482 } else { | |
4483 throw jsonDecoder.missingKey(jsonPath, "id"); | |
4484 } | |
4485 return new SearchFindTopLevelDeclarationsResult(id); | |
4486 } else { | |
4487 throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations resu
lt", json); | |
4488 } | |
4489 } | |
4490 | |
4491 factory SearchFindTopLevelDeclarationsResult.fromResponse(Response response) { | |
4492 return new SearchFindTopLevelDeclarationsResult.fromJson( | |
4493 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
4494 } | |
4495 | |
4496 Map<String, dynamic> toJson() { | |
4497 Map<String, dynamic> result = {}; | |
4498 result["id"] = id; | |
4499 return result; | |
4500 } | |
4501 | |
4502 Response toResponse(String id) { | |
4503 return new Response(id, result: toJson()); | |
4504 } | |
4505 | |
4506 @override | |
4507 String toString() => JSON.encode(toJson()); | |
4508 | |
4509 @override | |
4510 bool operator==(other) { | |
4511 if (other is SearchFindTopLevelDeclarationsResult) { | |
4512 return id == other.id; | |
4513 } | |
4514 return false; | |
4515 } | |
4516 | |
4517 @override | |
4518 int get hashCode { | |
4519 int hash = 0; | |
4520 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
4521 return _JenkinsSmiHash.finish(hash); | |
4522 } | |
4523 } | |
4524 | |
4525 /** | |
4526 * search.getTypeHierarchy params | |
4527 * | |
4528 * { | |
4529 * "file": FilePath | |
4530 * "offset": int | |
4531 * "superOnly": optional bool | |
4532 * } | |
4533 */ | |
4534 class SearchGetTypeHierarchyParams implements HasToJson { | |
4535 String _file; | |
4536 | |
4537 int _offset; | |
4538 | |
4539 bool _superOnly; | |
4540 | |
4541 /** | |
4542 * The file containing the declaration or reference to the type for which a | |
4543 * hierarchy is being requested. | |
4544 */ | |
4545 String get file => _file; | |
4546 | |
4547 /** | |
4548 * The file containing the declaration or reference to the type for which a | |
4549 * hierarchy is being requested. | |
4550 */ | |
4551 void set file(String value) { | |
4552 assert(value != null); | |
4553 this._file = value; | |
4554 } | |
4555 | |
4556 /** | |
4557 * The offset of the name of the type within the file. | |
4558 */ | |
4559 int get offset => _offset; | |
4560 | |
4561 /** | |
4562 * The offset of the name of the type within the file. | |
4563 */ | |
4564 void set offset(int value) { | |
4565 assert(value != null); | |
4566 this._offset = value; | |
4567 } | |
4568 | |
4569 /** | |
4570 * True if the client is only requesting superclasses and interfaces | |
4571 * hierarchy. | |
4572 */ | |
4573 bool get superOnly => _superOnly; | |
4574 | |
4575 /** | |
4576 * True if the client is only requesting superclasses and interfaces | |
4577 * hierarchy. | |
4578 */ | |
4579 void set superOnly(bool value) { | |
4580 this._superOnly = value; | |
4581 } | |
4582 | |
4583 SearchGetTypeHierarchyParams(String file, int offset, {bool superOnly}) { | |
4584 this.file = file; | |
4585 this.offset = offset; | |
4586 this.superOnly = superOnly; | |
4587 } | |
4588 | |
4589 factory SearchGetTypeHierarchyParams.fromJson(JsonDecoder jsonDecoder, String
jsonPath, Object json) { | |
4590 if (json == null) { | |
4591 json = {}; | |
4592 } | |
4593 if (json is Map) { | |
4594 String file; | |
4595 if (json.containsKey("file")) { | |
4596 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
4597 } else { | |
4598 throw jsonDecoder.missingKey(jsonPath, "file"); | |
4599 } | |
4600 int offset; | |
4601 if (json.containsKey("offset")) { | |
4602 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
4603 } else { | |
4604 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
4605 } | |
4606 bool superOnly; | |
4607 if (json.containsKey("superOnly")) { | |
4608 superOnly = jsonDecoder._decodeBool(jsonPath + ".superOnly", json["super
Only"]); | |
4609 } | |
4610 return new SearchGetTypeHierarchyParams(file, offset, superOnly: superOnly
); | |
4611 } else { | |
4612 throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy params", jso
n); | |
4613 } | |
4614 } | |
4615 | |
4616 factory SearchGetTypeHierarchyParams.fromRequest(Request request) { | |
4617 return new SearchGetTypeHierarchyParams.fromJson( | |
4618 new RequestDecoder(request), "params", request._params); | |
4619 } | |
4620 | |
4621 Map<String, dynamic> toJson() { | |
4622 Map<String, dynamic> result = {}; | |
4623 result["file"] = file; | |
4624 result["offset"] = offset; | |
4625 if (superOnly != null) { | |
4626 result["superOnly"] = superOnly; | |
4627 } | |
4628 return result; | |
4629 } | |
4630 | |
4631 Request toRequest(String id) { | |
4632 return new Request(id, "search.getTypeHierarchy", toJson()); | |
4633 } | |
4634 | |
4635 @override | |
4636 String toString() => JSON.encode(toJson()); | |
4637 | |
4638 @override | |
4639 bool operator==(other) { | |
4640 if (other is SearchGetTypeHierarchyParams) { | |
4641 return file == other.file && | |
4642 offset == other.offset && | |
4643 superOnly == other.superOnly; | |
4644 } | |
4645 return false; | |
4646 } | |
4647 | |
4648 @override | |
4649 int get hashCode { | |
4650 int hash = 0; | |
4651 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
4652 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
4653 hash = _JenkinsSmiHash.combine(hash, superOnly.hashCode); | |
4654 return _JenkinsSmiHash.finish(hash); | |
4655 } | |
4656 } | |
4657 | |
4658 /** | |
4659 * search.getTypeHierarchy result | |
4660 * | |
4661 * { | |
4662 * "hierarchyItems": optional List<TypeHierarchyItem> | |
4663 * } | |
4664 */ | |
4665 class SearchGetTypeHierarchyResult implements HasToJson { | |
4666 List<TypeHierarchyItem> _hierarchyItems; | |
4667 | |
4668 /** | |
4669 * A list of the types in the requested hierarchy. The first element of the | |
4670 * list is the item representing the type for which the hierarchy was | |
4671 * requested. The index of other elements of the list is unspecified, but | |
4672 * correspond to the integers used to reference supertype and subtype items | |
4673 * within the items. | |
4674 * | |
4675 * This field will be absent if the code at the given file and offset does | |
4676 * not represent a type, or if the file has not been sufficiently analyzed to | |
4677 * allow a type hierarchy to be produced. | |
4678 */ | |
4679 List<TypeHierarchyItem> get hierarchyItems => _hierarchyItems; | |
4680 | |
4681 /** | |
4682 * A list of the types in the requested hierarchy. The first element of the | |
4683 * list is the item representing the type for which the hierarchy was | |
4684 * requested. The index of other elements of the list is unspecified, but | |
4685 * correspond to the integers used to reference supertype and subtype items | |
4686 * within the items. | |
4687 * | |
4688 * This field will be absent if the code at the given file and offset does | |
4689 * not represent a type, or if the file has not been sufficiently analyzed to | |
4690 * allow a type hierarchy to be produced. | |
4691 */ | |
4692 void set hierarchyItems(List<TypeHierarchyItem> value) { | |
4693 this._hierarchyItems = value; | |
4694 } | |
4695 | |
4696 SearchGetTypeHierarchyResult({List<TypeHierarchyItem> hierarchyItems}) { | |
4697 this.hierarchyItems = hierarchyItems; | |
4698 } | |
4699 | |
4700 factory SearchGetTypeHierarchyResult.fromJson(JsonDecoder jsonDecoder, String
jsonPath, Object json) { | |
4701 if (json == null) { | |
4702 json = {}; | |
4703 } | |
4704 if (json is Map) { | |
4705 List<TypeHierarchyItem> hierarchyItems; | |
4706 if (json.containsKey("hierarchyItems")) { | |
4707 hierarchyItems = jsonDecoder._decodeList(jsonPath + ".hierarchyItems", j
son["hierarchyItems"], (String jsonPath, Object json) => new TypeHierarchyItem.f
romJson(jsonDecoder, jsonPath, json)); | |
4708 } | |
4709 return new SearchGetTypeHierarchyResult(hierarchyItems: hierarchyItems); | |
4710 } else { | |
4711 throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result", jso
n); | |
4712 } | |
4713 } | |
4714 | |
4715 factory SearchGetTypeHierarchyResult.fromResponse(Response response) { | |
4716 return new SearchGetTypeHierarchyResult.fromJson( | |
4717 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
4718 } | |
4719 | |
4720 Map<String, dynamic> toJson() { | |
4721 Map<String, dynamic> result = {}; | |
4722 if (hierarchyItems != null) { | |
4723 result["hierarchyItems"] = hierarchyItems.map((TypeHierarchyItem value) =>
value.toJson()).toList(); | |
4724 } | |
4725 return result; | |
4726 } | |
4727 | |
4728 Response toResponse(String id) { | |
4729 return new Response(id, result: toJson()); | |
4730 } | |
4731 | |
4732 @override | |
4733 String toString() => JSON.encode(toJson()); | |
4734 | |
4735 @override | |
4736 bool operator==(other) { | |
4737 if (other is SearchGetTypeHierarchyResult) { | |
4738 return _listEqual(hierarchyItems, other.hierarchyItems, (TypeHierarchyItem
a, TypeHierarchyItem b) => a == b); | |
4739 } | |
4740 return false; | |
4741 } | |
4742 | |
4743 @override | |
4744 int get hashCode { | |
4745 int hash = 0; | |
4746 hash = _JenkinsSmiHash.combine(hash, hierarchyItems.hashCode); | |
4747 return _JenkinsSmiHash.finish(hash); | |
4748 } | |
4749 } | |
4750 | |
4751 /** | |
4752 * search.results params | |
4753 * | |
4754 * { | |
4755 * "id": SearchId | |
4756 * "results": List<SearchResult> | |
4757 * "isLast": bool | |
4758 * } | |
4759 */ | |
4760 class SearchResultsParams implements HasToJson { | |
4761 String _id; | |
4762 | |
4763 List<SearchResult> _results; | |
4764 | |
4765 bool _isLast; | |
4766 | |
4767 /** | |
4768 * The id associated with the search. | |
4769 */ | |
4770 String get id => _id; | |
4771 | |
4772 /** | |
4773 * The id associated with the search. | |
4774 */ | |
4775 void set id(String value) { | |
4776 assert(value != null); | |
4777 this._id = value; | |
4778 } | |
4779 | |
4780 /** | |
4781 * The search results being reported. | |
4782 */ | |
4783 List<SearchResult> get results => _results; | |
4784 | |
4785 /** | |
4786 * The search results being reported. | |
4787 */ | |
4788 void set results(List<SearchResult> value) { | |
4789 assert(value != null); | |
4790 this._results = value; | |
4791 } | |
4792 | |
4793 /** | |
4794 * True if this is that last set of results that will be returned for the | |
4795 * indicated search. | |
4796 */ | |
4797 bool get isLast => _isLast; | |
4798 | |
4799 /** | |
4800 * True if this is that last set of results that will be returned for the | |
4801 * indicated search. | |
4802 */ | |
4803 void set isLast(bool value) { | |
4804 assert(value != null); | |
4805 this._isLast = value; | |
4806 } | |
4807 | |
4808 SearchResultsParams(String id, List<SearchResult> results, bool isLast) { | |
4809 this.id = id; | |
4810 this.results = results; | |
4811 this.isLast = isLast; | |
4812 } | |
4813 | |
4814 factory SearchResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json) { | |
4815 if (json == null) { | |
4816 json = {}; | |
4817 } | |
4818 if (json is Map) { | |
4819 String id; | |
4820 if (json.containsKey("id")) { | |
4821 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
4822 } else { | |
4823 throw jsonDecoder.missingKey(jsonPath, "id"); | |
4824 } | |
4825 List<SearchResult> results; | |
4826 if (json.containsKey("results")) { | |
4827 results = jsonDecoder._decodeList(jsonPath + ".results", json["results"]
, (String jsonPath, Object json) => new SearchResult.fromJson(jsonDecoder, jsonP
ath, json)); | |
4828 } else { | |
4829 throw jsonDecoder.missingKey(jsonPath, "results"); | |
4830 } | |
4831 bool isLast; | |
4832 if (json.containsKey("isLast")) { | |
4833 isLast = jsonDecoder._decodeBool(jsonPath + ".isLast", json["isLast"]); | |
4834 } else { | |
4835 throw jsonDecoder.missingKey(jsonPath, "isLast"); | |
4836 } | |
4837 return new SearchResultsParams(id, results, isLast); | |
4838 } else { | |
4839 throw jsonDecoder.mismatch(jsonPath, "search.results params", json); | |
4840 } | |
4841 } | |
4842 | |
4843 factory SearchResultsParams.fromNotification(Notification notification) { | |
4844 return new SearchResultsParams.fromJson( | |
4845 new ResponseDecoder(null), "params", notification._params); | |
4846 } | |
4847 | |
4848 Map<String, dynamic> toJson() { | |
4849 Map<String, dynamic> result = {}; | |
4850 result["id"] = id; | |
4851 result["results"] = results.map((SearchResult value) => value.toJson()).toLi
st(); | |
4852 result["isLast"] = isLast; | |
4853 return result; | |
4854 } | |
4855 | |
4856 Notification toNotification() { | |
4857 return new Notification("search.results", toJson()); | |
4858 } | |
4859 | |
4860 @override | |
4861 String toString() => JSON.encode(toJson()); | |
4862 | |
4863 @override | |
4864 bool operator==(other) { | |
4865 if (other is SearchResultsParams) { | |
4866 return id == other.id && | |
4867 _listEqual(results, other.results, (SearchResult a, SearchResult b) =>
a == b) && | |
4868 isLast == other.isLast; | |
4869 } | |
4870 return false; | |
4871 } | |
4872 | |
4873 @override | |
4874 int get hashCode { | |
4875 int hash = 0; | |
4876 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
4877 hash = _JenkinsSmiHash.combine(hash, results.hashCode); | |
4878 hash = _JenkinsSmiHash.combine(hash, isLast.hashCode); | |
4879 return _JenkinsSmiHash.finish(hash); | |
4880 } | |
4881 } | |
4882 | |
4883 /** | |
4884 * edit.format params | |
4885 * | |
4886 * { | |
4887 * "file": FilePath | |
4888 * "selectionOffset": int | |
4889 * "selectionLength": int | |
4890 * "lineLength": optional int | |
4891 * } | |
4892 */ | |
4893 class EditFormatParams implements HasToJson { | |
4894 String _file; | |
4895 | |
4896 int _selectionOffset; | |
4897 | |
4898 int _selectionLength; | |
4899 | |
4900 int _lineLength; | |
4901 | |
4902 /** | |
4903 * The file containing the code to be formatted. | |
4904 */ | |
4905 String get file => _file; | |
4906 | |
4907 /** | |
4908 * The file containing the code to be formatted. | |
4909 */ | |
4910 void set file(String value) { | |
4911 assert(value != null); | |
4912 this._file = value; | |
4913 } | |
4914 | |
4915 /** | |
4916 * The offset of the current selection in the file. | |
4917 */ | |
4918 int get selectionOffset => _selectionOffset; | |
4919 | |
4920 /** | |
4921 * The offset of the current selection in the file. | |
4922 */ | |
4923 void set selectionOffset(int value) { | |
4924 assert(value != null); | |
4925 this._selectionOffset = value; | |
4926 } | |
4927 | |
4928 /** | |
4929 * The length of the current selection in the file. | |
4930 */ | |
4931 int get selectionLength => _selectionLength; | |
4932 | |
4933 /** | |
4934 * The length of the current selection in the file. | |
4935 */ | |
4936 void set selectionLength(int value) { | |
4937 assert(value != null); | |
4938 this._selectionLength = value; | |
4939 } | |
4940 | |
4941 /** | |
4942 * The line length to be used by the formatter. | |
4943 */ | |
4944 int get lineLength => _lineLength; | |
4945 | |
4946 /** | |
4947 * The line length to be used by the formatter. | |
4948 */ | |
4949 void set lineLength(int value) { | |
4950 this._lineLength = value; | |
4951 } | |
4952 | |
4953 EditFormatParams(String file, int selectionOffset, int selectionLength, {int l
ineLength}) { | |
4954 this.file = file; | |
4955 this.selectionOffset = selectionOffset; | |
4956 this.selectionLength = selectionLength; | |
4957 this.lineLength = lineLength; | |
4958 } | |
4959 | |
4960 factory EditFormatParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
4961 if (json == null) { | |
4962 json = {}; | |
4963 } | |
4964 if (json is Map) { | |
4965 String file; | |
4966 if (json.containsKey("file")) { | |
4967 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
4968 } else { | |
4969 throw jsonDecoder.missingKey(jsonPath, "file"); | |
4970 } | |
4971 int selectionOffset; | |
4972 if (json.containsKey("selectionOffset")) { | |
4973 selectionOffset = jsonDecoder._decodeInt(jsonPath + ".selectionOffset",
json["selectionOffset"]); | |
4974 } else { | |
4975 throw jsonDecoder.missingKey(jsonPath, "selectionOffset"); | |
4976 } | |
4977 int selectionLength; | |
4978 if (json.containsKey("selectionLength")) { | |
4979 selectionLength = jsonDecoder._decodeInt(jsonPath + ".selectionLength",
json["selectionLength"]); | |
4980 } else { | |
4981 throw jsonDecoder.missingKey(jsonPath, "selectionLength"); | |
4982 } | |
4983 int lineLength; | |
4984 if (json.containsKey("lineLength")) { | |
4985 lineLength = jsonDecoder._decodeInt(jsonPath + ".lineLength", json["line
Length"]); | |
4986 } | |
4987 return new EditFormatParams(file, selectionOffset, selectionLength, lineLe
ngth: lineLength); | |
4988 } else { | |
4989 throw jsonDecoder.mismatch(jsonPath, "edit.format params", json); | |
4990 } | |
4991 } | |
4992 | |
4993 factory EditFormatParams.fromRequest(Request request) { | |
4994 return new EditFormatParams.fromJson( | |
4995 new RequestDecoder(request), "params", request._params); | |
4996 } | |
4997 | |
4998 Map<String, dynamic> toJson() { | |
4999 Map<String, dynamic> result = {}; | |
5000 result["file"] = file; | |
5001 result["selectionOffset"] = selectionOffset; | |
5002 result["selectionLength"] = selectionLength; | |
5003 if (lineLength != null) { | |
5004 result["lineLength"] = lineLength; | |
5005 } | |
5006 return result; | |
5007 } | |
5008 | |
5009 Request toRequest(String id) { | |
5010 return new Request(id, "edit.format", toJson()); | |
5011 } | |
5012 | |
5013 @override | |
5014 String toString() => JSON.encode(toJson()); | |
5015 | |
5016 @override | |
5017 bool operator==(other) { | |
5018 if (other is EditFormatParams) { | |
5019 return file == other.file && | |
5020 selectionOffset == other.selectionOffset && | |
5021 selectionLength == other.selectionLength && | |
5022 lineLength == other.lineLength; | |
5023 } | |
5024 return false; | |
5025 } | |
5026 | |
5027 @override | |
5028 int get hashCode { | |
5029 int hash = 0; | |
5030 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
5031 hash = _JenkinsSmiHash.combine(hash, selectionOffset.hashCode); | |
5032 hash = _JenkinsSmiHash.combine(hash, selectionLength.hashCode); | |
5033 hash = _JenkinsSmiHash.combine(hash, lineLength.hashCode); | |
5034 return _JenkinsSmiHash.finish(hash); | |
5035 } | |
5036 } | |
5037 | |
5038 /** | |
5039 * edit.format result | |
5040 * | |
5041 * { | |
5042 * "edits": List<SourceEdit> | |
5043 * "selectionOffset": int | |
5044 * "selectionLength": int | |
5045 * } | |
5046 */ | |
5047 class EditFormatResult implements HasToJson { | |
5048 List<SourceEdit> _edits; | |
5049 | |
5050 int _selectionOffset; | |
5051 | |
5052 int _selectionLength; | |
5053 | |
5054 /** | |
5055 * The edit(s) to be applied in order to format the code. The list will be | |
5056 * empty if the code was already formatted (there are no changes). | |
5057 */ | |
5058 List<SourceEdit> get edits => _edits; | |
5059 | |
5060 /** | |
5061 * The edit(s) to be applied in order to format the code. The list will be | |
5062 * empty if the code was already formatted (there are no changes). | |
5063 */ | |
5064 void set edits(List<SourceEdit> value) { | |
5065 assert(value != null); | |
5066 this._edits = value; | |
5067 } | |
5068 | |
5069 /** | |
5070 * The offset of the selection after formatting the code. | |
5071 */ | |
5072 int get selectionOffset => _selectionOffset; | |
5073 | |
5074 /** | |
5075 * The offset of the selection after formatting the code. | |
5076 */ | |
5077 void set selectionOffset(int value) { | |
5078 assert(value != null); | |
5079 this._selectionOffset = value; | |
5080 } | |
5081 | |
5082 /** | |
5083 * The length of the selection after formatting the code. | |
5084 */ | |
5085 int get selectionLength => _selectionLength; | |
5086 | |
5087 /** | |
5088 * The length of the selection after formatting the code. | |
5089 */ | |
5090 void set selectionLength(int value) { | |
5091 assert(value != null); | |
5092 this._selectionLength = value; | |
5093 } | |
5094 | |
5095 EditFormatResult(List<SourceEdit> edits, int selectionOffset, int selectionLen
gth) { | |
5096 this.edits = edits; | |
5097 this.selectionOffset = selectionOffset; | |
5098 this.selectionLength = selectionLength; | |
5099 } | |
5100 | |
5101 factory EditFormatResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
5102 if (json == null) { | |
5103 json = {}; | |
5104 } | |
5105 if (json is Map) { | |
5106 List<SourceEdit> edits; | |
5107 if (json.containsKey("edits")) { | |
5108 edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (Str
ing jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, jso
n)); | |
5109 } else { | |
5110 throw jsonDecoder.missingKey(jsonPath, "edits"); | |
5111 } | |
5112 int selectionOffset; | |
5113 if (json.containsKey("selectionOffset")) { | |
5114 selectionOffset = jsonDecoder._decodeInt(jsonPath + ".selectionOffset",
json["selectionOffset"]); | |
5115 } else { | |
5116 throw jsonDecoder.missingKey(jsonPath, "selectionOffset"); | |
5117 } | |
5118 int selectionLength; | |
5119 if (json.containsKey("selectionLength")) { | |
5120 selectionLength = jsonDecoder._decodeInt(jsonPath + ".selectionLength",
json["selectionLength"]); | |
5121 } else { | |
5122 throw jsonDecoder.missingKey(jsonPath, "selectionLength"); | |
5123 } | |
5124 return new EditFormatResult(edits, selectionOffset, selectionLength); | |
5125 } else { | |
5126 throw jsonDecoder.mismatch(jsonPath, "edit.format result", json); | |
5127 } | |
5128 } | |
5129 | |
5130 factory EditFormatResult.fromResponse(Response response) { | |
5131 return new EditFormatResult.fromJson( | |
5132 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
5133 } | |
5134 | |
5135 Map<String, dynamic> toJson() { | |
5136 Map<String, dynamic> result = {}; | |
5137 result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList(); | |
5138 result["selectionOffset"] = selectionOffset; | |
5139 result["selectionLength"] = selectionLength; | |
5140 return result; | |
5141 } | |
5142 | |
5143 Response toResponse(String id) { | |
5144 return new Response(id, result: toJson()); | |
5145 } | |
5146 | |
5147 @override | |
5148 String toString() => JSON.encode(toJson()); | |
5149 | |
5150 @override | |
5151 bool operator==(other) { | |
5152 if (other is EditFormatResult) { | |
5153 return _listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a ==
b) && | |
5154 selectionOffset == other.selectionOffset && | |
5155 selectionLength == other.selectionLength; | |
5156 } | |
5157 return false; | |
5158 } | |
5159 | |
5160 @override | |
5161 int get hashCode { | |
5162 int hash = 0; | |
5163 hash = _JenkinsSmiHash.combine(hash, edits.hashCode); | |
5164 hash = _JenkinsSmiHash.combine(hash, selectionOffset.hashCode); | |
5165 hash = _JenkinsSmiHash.combine(hash, selectionLength.hashCode); | |
5166 return _JenkinsSmiHash.finish(hash); | |
5167 } | |
5168 } | |
5169 | |
5170 /** | |
5171 * edit.getAssists params | |
5172 * | |
5173 * { | |
5174 * "file": FilePath | |
5175 * "offset": int | |
5176 * "length": int | |
5177 * } | |
5178 */ | |
5179 class EditGetAssistsParams implements HasToJson { | |
5180 String _file; | |
5181 | |
5182 int _offset; | |
5183 | |
5184 int _length; | |
5185 | |
5186 /** | |
5187 * The file containing the code for which assists are being requested. | |
5188 */ | |
5189 String get file => _file; | |
5190 | |
5191 /** | |
5192 * The file containing the code for which assists are being requested. | |
5193 */ | |
5194 void set file(String value) { | |
5195 assert(value != null); | |
5196 this._file = value; | |
5197 } | |
5198 | |
5199 /** | |
5200 * The offset of the code for which assists are being requested. | |
5201 */ | |
5202 int get offset => _offset; | |
5203 | |
5204 /** | |
5205 * The offset of the code for which assists are being requested. | |
5206 */ | |
5207 void set offset(int value) { | |
5208 assert(value != null); | |
5209 this._offset = value; | |
5210 } | |
5211 | |
5212 /** | |
5213 * The length of the code for which assists are being requested. | |
5214 */ | |
5215 int get length => _length; | |
5216 | |
5217 /** | |
5218 * The length of the code for which assists are being requested. | |
5219 */ | |
5220 void set length(int value) { | |
5221 assert(value != null); | |
5222 this._length = value; | |
5223 } | |
5224 | |
5225 EditGetAssistsParams(String file, int offset, int length) { | |
5226 this.file = file; | |
5227 this.offset = offset; | |
5228 this.length = length; | |
5229 } | |
5230 | |
5231 factory EditGetAssistsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath
, Object json) { | |
5232 if (json == null) { | |
5233 json = {}; | |
5234 } | |
5235 if (json is Map) { | |
5236 String file; | |
5237 if (json.containsKey("file")) { | |
5238 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
5239 } else { | |
5240 throw jsonDecoder.missingKey(jsonPath, "file"); | |
5241 } | |
5242 int offset; | |
5243 if (json.containsKey("offset")) { | |
5244 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
5245 } else { | |
5246 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
5247 } | |
5248 int length; | |
5249 if (json.containsKey("length")) { | |
5250 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
5251 } else { | |
5252 throw jsonDecoder.missingKey(jsonPath, "length"); | |
5253 } | |
5254 return new EditGetAssistsParams(file, offset, length); | |
5255 } else { | |
5256 throw jsonDecoder.mismatch(jsonPath, "edit.getAssists params", json); | |
5257 } | |
5258 } | |
5259 | |
5260 factory EditGetAssistsParams.fromRequest(Request request) { | |
5261 return new EditGetAssistsParams.fromJson( | |
5262 new RequestDecoder(request), "params", request._params); | |
5263 } | |
5264 | |
5265 Map<String, dynamic> toJson() { | |
5266 Map<String, dynamic> result = {}; | |
5267 result["file"] = file; | |
5268 result["offset"] = offset; | |
5269 result["length"] = length; | |
5270 return result; | |
5271 } | |
5272 | |
5273 Request toRequest(String id) { | |
5274 return new Request(id, "edit.getAssists", toJson()); | |
5275 } | |
5276 | |
5277 @override | |
5278 String toString() => JSON.encode(toJson()); | |
5279 | |
5280 @override | |
5281 bool operator==(other) { | |
5282 if (other is EditGetAssistsParams) { | |
5283 return file == other.file && | |
5284 offset == other.offset && | |
5285 length == other.length; | |
5286 } | |
5287 return false; | |
5288 } | |
5289 | |
5290 @override | |
5291 int get hashCode { | |
5292 int hash = 0; | |
5293 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
5294 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
5295 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
5296 return _JenkinsSmiHash.finish(hash); | |
5297 } | |
5298 } | |
5299 | |
5300 /** | |
5301 * edit.getAssists result | |
5302 * | |
5303 * { | |
5304 * "assists": List<SourceChange> | |
5305 * } | |
5306 */ | |
5307 class EditGetAssistsResult implements HasToJson { | |
5308 List<SourceChange> _assists; | |
5309 | |
5310 /** | |
5311 * The assists that are available at the given location. | |
5312 */ | |
5313 List<SourceChange> get assists => _assists; | |
5314 | |
5315 /** | |
5316 * The assists that are available at the given location. | |
5317 */ | |
5318 void set assists(List<SourceChange> value) { | |
5319 assert(value != null); | |
5320 this._assists = value; | |
5321 } | |
5322 | |
5323 EditGetAssistsResult(List<SourceChange> assists) { | |
5324 this.assists = assists; | |
5325 } | |
5326 | |
5327 factory EditGetAssistsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath
, Object json) { | |
5328 if (json == null) { | |
5329 json = {}; | |
5330 } | |
5331 if (json is Map) { | |
5332 List<SourceChange> assists; | |
5333 if (json.containsKey("assists")) { | |
5334 assists = jsonDecoder._decodeList(jsonPath + ".assists", json["assists"]
, (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonP
ath, json)); | |
5335 } else { | |
5336 throw jsonDecoder.missingKey(jsonPath, "assists"); | |
5337 } | |
5338 return new EditGetAssistsResult(assists); | |
5339 } else { | |
5340 throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result", json); | |
5341 } | |
5342 } | |
5343 | |
5344 factory EditGetAssistsResult.fromResponse(Response response) { | |
5345 return new EditGetAssistsResult.fromJson( | |
5346 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
5347 } | |
5348 | |
5349 Map<String, dynamic> toJson() { | |
5350 Map<String, dynamic> result = {}; | |
5351 result["assists"] = assists.map((SourceChange value) => value.toJson()).toLi
st(); | |
5352 return result; | |
5353 } | |
5354 | |
5355 Response toResponse(String id) { | |
5356 return new Response(id, result: toJson()); | |
5357 } | |
5358 | |
5359 @override | |
5360 String toString() => JSON.encode(toJson()); | |
5361 | |
5362 @override | |
5363 bool operator==(other) { | |
5364 if (other is EditGetAssistsResult) { | |
5365 return _listEqual(assists, other.assists, (SourceChange a, SourceChange b)
=> a == b); | |
5366 } | |
5367 return false; | |
5368 } | |
5369 | |
5370 @override | |
5371 int get hashCode { | |
5372 int hash = 0; | |
5373 hash = _JenkinsSmiHash.combine(hash, assists.hashCode); | |
5374 return _JenkinsSmiHash.finish(hash); | |
5375 } | |
5376 } | |
5377 | |
5378 /** | |
5379 * edit.getAvailableRefactorings params | |
5380 * | |
5381 * { | |
5382 * "file": FilePath | |
5383 * "offset": int | |
5384 * "length": int | |
5385 * } | |
5386 */ | |
5387 class EditGetAvailableRefactoringsParams implements HasToJson { | |
5388 String _file; | |
5389 | |
5390 int _offset; | |
5391 | |
5392 int _length; | |
5393 | |
5394 /** | |
5395 * The file containing the code on which the refactoring would be based. | |
5396 */ | |
5397 String get file => _file; | |
5398 | |
5399 /** | |
5400 * The file containing the code on which the refactoring would be based. | |
5401 */ | |
5402 void set file(String value) { | |
5403 assert(value != null); | |
5404 this._file = value; | |
5405 } | |
5406 | |
5407 /** | |
5408 * The offset of the code on which the refactoring would be based. | |
5409 */ | |
5410 int get offset => _offset; | |
5411 | |
5412 /** | |
5413 * The offset of the code on which the refactoring would be based. | |
5414 */ | |
5415 void set offset(int value) { | |
5416 assert(value != null); | |
5417 this._offset = value; | |
5418 } | |
5419 | |
5420 /** | |
5421 * The length of the code on which the refactoring would be based. | |
5422 */ | |
5423 int get length => _length; | |
5424 | |
5425 /** | |
5426 * The length of the code on which the refactoring would be based. | |
5427 */ | |
5428 void set length(int value) { | |
5429 assert(value != null); | |
5430 this._length = value; | |
5431 } | |
5432 | |
5433 EditGetAvailableRefactoringsParams(String file, int offset, int length) { | |
5434 this.file = file; | |
5435 this.offset = offset; | |
5436 this.length = length; | |
5437 } | |
5438 | |
5439 factory EditGetAvailableRefactoringsParams.fromJson(JsonDecoder jsonDecoder, S
tring jsonPath, Object json) { | |
5440 if (json == null) { | |
5441 json = {}; | |
5442 } | |
5443 if (json is Map) { | |
5444 String file; | |
5445 if (json.containsKey("file")) { | |
5446 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
5447 } else { | |
5448 throw jsonDecoder.missingKey(jsonPath, "file"); | |
5449 } | |
5450 int offset; | |
5451 if (json.containsKey("offset")) { | |
5452 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
5453 } else { | |
5454 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
5455 } | |
5456 int length; | |
5457 if (json.containsKey("length")) { | |
5458 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
5459 } else { | |
5460 throw jsonDecoder.missingKey(jsonPath, "length"); | |
5461 } | |
5462 return new EditGetAvailableRefactoringsParams(file, offset, length); | |
5463 } else { | |
5464 throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings params
", json); | |
5465 } | |
5466 } | |
5467 | |
5468 factory EditGetAvailableRefactoringsParams.fromRequest(Request request) { | |
5469 return new EditGetAvailableRefactoringsParams.fromJson( | |
5470 new RequestDecoder(request), "params", request._params); | |
5471 } | |
5472 | |
5473 Map<String, dynamic> toJson() { | |
5474 Map<String, dynamic> result = {}; | |
5475 result["file"] = file; | |
5476 result["offset"] = offset; | |
5477 result["length"] = length; | |
5478 return result; | |
5479 } | |
5480 | |
5481 Request toRequest(String id) { | |
5482 return new Request(id, "edit.getAvailableRefactorings", toJson()); | |
5483 } | |
5484 | |
5485 @override | |
5486 String toString() => JSON.encode(toJson()); | |
5487 | |
5488 @override | |
5489 bool operator==(other) { | |
5490 if (other is EditGetAvailableRefactoringsParams) { | |
5491 return file == other.file && | |
5492 offset == other.offset && | |
5493 length == other.length; | |
5494 } | |
5495 return false; | |
5496 } | |
5497 | |
5498 @override | |
5499 int get hashCode { | |
5500 int hash = 0; | |
5501 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
5502 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
5503 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
5504 return _JenkinsSmiHash.finish(hash); | |
5505 } | |
5506 } | |
5507 | |
5508 /** | |
5509 * edit.getAvailableRefactorings result | |
5510 * | |
5511 * { | |
5512 * "kinds": List<RefactoringKind> | |
5513 * } | |
5514 */ | |
5515 class EditGetAvailableRefactoringsResult implements HasToJson { | |
5516 List<RefactoringKind> _kinds; | |
5517 | |
5518 /** | |
5519 * The kinds of refactorings that are valid for the given selection. | |
5520 */ | |
5521 List<RefactoringKind> get kinds => _kinds; | |
5522 | |
5523 /** | |
5524 * The kinds of refactorings that are valid for the given selection. | |
5525 */ | |
5526 void set kinds(List<RefactoringKind> value) { | |
5527 assert(value != null); | |
5528 this._kinds = value; | |
5529 } | |
5530 | |
5531 EditGetAvailableRefactoringsResult(List<RefactoringKind> kinds) { | |
5532 this.kinds = kinds; | |
5533 } | |
5534 | |
5535 factory EditGetAvailableRefactoringsResult.fromJson(JsonDecoder jsonDecoder, S
tring jsonPath, Object json) { | |
5536 if (json == null) { | |
5537 json = {}; | |
5538 } | |
5539 if (json is Map) { | |
5540 List<RefactoringKind> kinds; | |
5541 if (json.containsKey("kinds")) { | |
5542 kinds = jsonDecoder._decodeList(jsonPath + ".kinds", json["kinds"], (Str
ing jsonPath, Object json) => new RefactoringKind.fromJson(jsonDecoder, jsonPath
, json)); | |
5543 } else { | |
5544 throw jsonDecoder.missingKey(jsonPath, "kinds"); | |
5545 } | |
5546 return new EditGetAvailableRefactoringsResult(kinds); | |
5547 } else { | |
5548 throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result
", json); | |
5549 } | |
5550 } | |
5551 | |
5552 factory EditGetAvailableRefactoringsResult.fromResponse(Response response) { | |
5553 return new EditGetAvailableRefactoringsResult.fromJson( | |
5554 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
5555 } | |
5556 | |
5557 Map<String, dynamic> toJson() { | |
5558 Map<String, dynamic> result = {}; | |
5559 result["kinds"] = kinds.map((RefactoringKind value) => value.toJson()).toLis
t(); | |
5560 return result; | |
5561 } | |
5562 | |
5563 Response toResponse(String id) { | |
5564 return new Response(id, result: toJson()); | |
5565 } | |
5566 | |
5567 @override | |
5568 String toString() => JSON.encode(toJson()); | |
5569 | |
5570 @override | |
5571 bool operator==(other) { | |
5572 if (other is EditGetAvailableRefactoringsResult) { | |
5573 return _listEqual(kinds, other.kinds, (RefactoringKind a, RefactoringKind
b) => a == b); | |
5574 } | |
5575 return false; | |
5576 } | |
5577 | |
5578 @override | |
5579 int get hashCode { | |
5580 int hash = 0; | |
5581 hash = _JenkinsSmiHash.combine(hash, kinds.hashCode); | |
5582 return _JenkinsSmiHash.finish(hash); | |
5583 } | |
5584 } | |
5585 | |
5586 /** | |
5587 * edit.getFixes params | |
5588 * | |
5589 * { | |
5590 * "file": FilePath | |
5591 * "offset": int | |
5592 * } | |
5593 */ | |
5594 class EditGetFixesParams implements HasToJson { | |
5595 String _file; | |
5596 | |
5597 int _offset; | |
5598 | |
5599 /** | |
5600 * The file containing the errors for which fixes are being requested. | |
5601 */ | |
5602 String get file => _file; | |
5603 | |
5604 /** | |
5605 * The file containing the errors for which fixes are being requested. | |
5606 */ | |
5607 void set file(String value) { | |
5608 assert(value != null); | |
5609 this._file = value; | |
5610 } | |
5611 | |
5612 /** | |
5613 * The offset used to select the errors for which fixes will be returned. | |
5614 */ | |
5615 int get offset => _offset; | |
5616 | |
5617 /** | |
5618 * The offset used to select the errors for which fixes will be returned. | |
5619 */ | |
5620 void set offset(int value) { | |
5621 assert(value != null); | |
5622 this._offset = value; | |
5623 } | |
5624 | |
5625 EditGetFixesParams(String file, int offset) { | |
5626 this.file = file; | |
5627 this.offset = offset; | |
5628 } | |
5629 | |
5630 factory EditGetFixesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json) { | |
5631 if (json == null) { | |
5632 json = {}; | |
5633 } | |
5634 if (json is Map) { | |
5635 String file; | |
5636 if (json.containsKey("file")) { | |
5637 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
5638 } else { | |
5639 throw jsonDecoder.missingKey(jsonPath, "file"); | |
5640 } | |
5641 int offset; | |
5642 if (json.containsKey("offset")) { | |
5643 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
5644 } else { | |
5645 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
5646 } | |
5647 return new EditGetFixesParams(file, offset); | |
5648 } else { | |
5649 throw jsonDecoder.mismatch(jsonPath, "edit.getFixes params", json); | |
5650 } | |
5651 } | |
5652 | |
5653 factory EditGetFixesParams.fromRequest(Request request) { | |
5654 return new EditGetFixesParams.fromJson( | |
5655 new RequestDecoder(request), "params", request._params); | |
5656 } | |
5657 | |
5658 Map<String, dynamic> toJson() { | |
5659 Map<String, dynamic> result = {}; | |
5660 result["file"] = file; | |
5661 result["offset"] = offset; | |
5662 return result; | |
5663 } | |
5664 | |
5665 Request toRequest(String id) { | |
5666 return new Request(id, "edit.getFixes", toJson()); | |
5667 } | |
5668 | |
5669 @override | |
5670 String toString() => JSON.encode(toJson()); | |
5671 | |
5672 @override | |
5673 bool operator==(other) { | |
5674 if (other is EditGetFixesParams) { | |
5675 return file == other.file && | |
5676 offset == other.offset; | |
5677 } | |
5678 return false; | |
5679 } | |
5680 | |
5681 @override | |
5682 int get hashCode { | |
5683 int hash = 0; | |
5684 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
5685 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
5686 return _JenkinsSmiHash.finish(hash); | |
5687 } | |
5688 } | |
5689 | |
5690 /** | |
5691 * edit.getFixes result | |
5692 * | |
5693 * { | |
5694 * "fixes": List<AnalysisErrorFixes> | |
5695 * } | |
5696 */ | |
5697 class EditGetFixesResult implements HasToJson { | |
5698 List<AnalysisErrorFixes> _fixes; | |
5699 | |
5700 /** | |
5701 * The fixes that are available for the errors at the given offset. | |
5702 */ | |
5703 List<AnalysisErrorFixes> get fixes => _fixes; | |
5704 | |
5705 /** | |
5706 * The fixes that are available for the errors at the given offset. | |
5707 */ | |
5708 void set fixes(List<AnalysisErrorFixes> value) { | |
5709 assert(value != null); | |
5710 this._fixes = value; | |
5711 } | |
5712 | |
5713 EditGetFixesResult(List<AnalysisErrorFixes> fixes) { | |
5714 this.fixes = fixes; | |
5715 } | |
5716 | |
5717 factory EditGetFixesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json) { | |
5718 if (json == null) { | |
5719 json = {}; | |
5720 } | |
5721 if (json is Map) { | |
5722 List<AnalysisErrorFixes> fixes; | |
5723 if (json.containsKey("fixes")) { | |
5724 fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (Str
ing jsonPath, Object json) => new AnalysisErrorFixes.fromJson(jsonDecoder, jsonP
ath, json)); | |
5725 } else { | |
5726 throw jsonDecoder.missingKey(jsonPath, "fixes"); | |
5727 } | |
5728 return new EditGetFixesResult(fixes); | |
5729 } else { | |
5730 throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result", json); | |
5731 } | |
5732 } | |
5733 | |
5734 factory EditGetFixesResult.fromResponse(Response response) { | |
5735 return new EditGetFixesResult.fromJson( | |
5736 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
5737 } | |
5738 | |
5739 Map<String, dynamic> toJson() { | |
5740 Map<String, dynamic> result = {}; | |
5741 result["fixes"] = fixes.map((AnalysisErrorFixes value) => value.toJson()).to
List(); | |
5742 return result; | |
5743 } | |
5744 | |
5745 Response toResponse(String id) { | |
5746 return new Response(id, result: toJson()); | |
5747 } | |
5748 | |
5749 @override | |
5750 String toString() => JSON.encode(toJson()); | |
5751 | |
5752 @override | |
5753 bool operator==(other) { | |
5754 if (other is EditGetFixesResult) { | |
5755 return _listEqual(fixes, other.fixes, (AnalysisErrorFixes a, AnalysisError
Fixes b) => a == b); | |
5756 } | |
5757 return false; | |
5758 } | |
5759 | |
5760 @override | |
5761 int get hashCode { | |
5762 int hash = 0; | |
5763 hash = _JenkinsSmiHash.combine(hash, fixes.hashCode); | |
5764 return _JenkinsSmiHash.finish(hash); | |
5765 } | |
5766 } | |
5767 | |
5768 /** | |
5769 * edit.getRefactoring params | |
5770 * | |
5771 * { | |
5772 * "kind": RefactoringKind | |
5773 * "file": FilePath | |
5774 * "offset": int | |
5775 * "length": int | |
5776 * "validateOnly": bool | |
5777 * "options": optional RefactoringOptions | |
5778 * } | |
5779 */ | |
5780 class EditGetRefactoringParams implements HasToJson { | |
5781 RefactoringKind _kind; | |
5782 | |
5783 String _file; | |
5784 | |
5785 int _offset; | |
5786 | |
5787 int _length; | |
5788 | |
5789 bool _validateOnly; | |
5790 | |
5791 RefactoringOptions _options; | |
5792 | |
5793 /** | |
5794 * The kind of refactoring to be performed. | |
5795 */ | |
5796 RefactoringKind get kind => _kind; | |
5797 | |
5798 /** | |
5799 * The kind of refactoring to be performed. | |
5800 */ | |
5801 void set kind(RefactoringKind value) { | |
5802 assert(value != null); | |
5803 this._kind = value; | |
5804 } | |
5805 | |
5806 /** | |
5807 * The file containing the code involved in the refactoring. | |
5808 */ | |
5809 String get file => _file; | |
5810 | |
5811 /** | |
5812 * The file containing the code involved in the refactoring. | |
5813 */ | |
5814 void set file(String value) { | |
5815 assert(value != null); | |
5816 this._file = value; | |
5817 } | |
5818 | |
5819 /** | |
5820 * The offset of the region involved in the refactoring. | |
5821 */ | |
5822 int get offset => _offset; | |
5823 | |
5824 /** | |
5825 * The offset of the region involved in the refactoring. | |
5826 */ | |
5827 void set offset(int value) { | |
5828 assert(value != null); | |
5829 this._offset = value; | |
5830 } | |
5831 | |
5832 /** | |
5833 * The length of the region involved in the refactoring. | |
5834 */ | |
5835 int get length => _length; | |
5836 | |
5837 /** | |
5838 * The length of the region involved in the refactoring. | |
5839 */ | |
5840 void set length(int value) { | |
5841 assert(value != null); | |
5842 this._length = value; | |
5843 } | |
5844 | |
5845 /** | |
5846 * True if the client is only requesting that the values of the options be | |
5847 * validated and no change be generated. | |
5848 */ | |
5849 bool get validateOnly => _validateOnly; | |
5850 | |
5851 /** | |
5852 * True if the client is only requesting that the values of the options be | |
5853 * validated and no change be generated. | |
5854 */ | |
5855 void set validateOnly(bool value) { | |
5856 assert(value != null); | |
5857 this._validateOnly = value; | |
5858 } | |
5859 | |
5860 /** | |
5861 * Data used to provide values provided by the user. The structure of the | |
5862 * data is dependent on the kind of refactoring being performed. The data | |
5863 * that is expected is documented in the section titled Refactorings, labeled | |
5864 * as “Options”. This field can be omitted if the refactoring does not | |
5865 * require any options or if the values of those options are not known. | |
5866 */ | |
5867 RefactoringOptions get options => _options; | |
5868 | |
5869 /** | |
5870 * Data used to provide values provided by the user. The structure of the | |
5871 * data is dependent on the kind of refactoring being performed. The data | |
5872 * that is expected is documented in the section titled Refactorings, labeled | |
5873 * as “Options”. This field can be omitted if the refactoring does not | |
5874 * require any options or if the values of those options are not known. | |
5875 */ | |
5876 void set options(RefactoringOptions value) { | |
5877 this._options = value; | |
5878 } | |
5879 | |
5880 EditGetRefactoringParams(RefactoringKind kind, String file, int offset, int le
ngth, bool validateOnly, {RefactoringOptions options}) { | |
5881 this.kind = kind; | |
5882 this.file = file; | |
5883 this.offset = offset; | |
5884 this.length = length; | |
5885 this.validateOnly = validateOnly; | |
5886 this.options = options; | |
5887 } | |
5888 | |
5889 factory EditGetRefactoringParams.fromJson(JsonDecoder jsonDecoder, String json
Path, Object json) { | |
5890 if (json == null) { | |
5891 json = {}; | |
5892 } | |
5893 if (json is Map) { | |
5894 RefactoringKind kind; | |
5895 if (json.containsKey("kind")) { | |
5896 kind = new RefactoringKind.fromJson(jsonDecoder, jsonPath + ".kind", jso
n["kind"]); | |
5897 } else { | |
5898 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
5899 } | |
5900 String file; | |
5901 if (json.containsKey("file")) { | |
5902 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
5903 } else { | |
5904 throw jsonDecoder.missingKey(jsonPath, "file"); | |
5905 } | |
5906 int offset; | |
5907 if (json.containsKey("offset")) { | |
5908 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
5909 } else { | |
5910 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
5911 } | |
5912 int length; | |
5913 if (json.containsKey("length")) { | |
5914 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
5915 } else { | |
5916 throw jsonDecoder.missingKey(jsonPath, "length"); | |
5917 } | |
5918 bool validateOnly; | |
5919 if (json.containsKey("validateOnly")) { | |
5920 validateOnly = jsonDecoder._decodeBool(jsonPath + ".validateOnly", json[
"validateOnly"]); | |
5921 } else { | |
5922 throw jsonDecoder.missingKey(jsonPath, "validateOnly"); | |
5923 } | |
5924 RefactoringOptions options; | |
5925 if (json.containsKey("options")) { | |
5926 options = new RefactoringOptions.fromJson(jsonDecoder, jsonPath + ".opti
ons", json["options"], kind); | |
5927 } | |
5928 return new EditGetRefactoringParams(kind, file, offset, length, validateOn
ly, options: options); | |
5929 } else { | |
5930 throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring params", json); | |
5931 } | |
5932 } | |
5933 | |
5934 factory EditGetRefactoringParams.fromRequest(Request request) { | |
5935 var params = new EditGetRefactoringParams.fromJson( | |
5936 new RequestDecoder(request), "params", request._params); | |
5937 REQUEST_ID_REFACTORING_KINDS[request.id] = params.kind; | |
5938 return params; | |
5939 } | |
5940 | |
5941 Map<String, dynamic> toJson() { | |
5942 Map<String, dynamic> result = {}; | |
5943 result["kind"] = kind.toJson(); | |
5944 result["file"] = file; | |
5945 result["offset"] = offset; | |
5946 result["length"] = length; | |
5947 result["validateOnly"] = validateOnly; | |
5948 if (options != null) { | |
5949 result["options"] = options.toJson(); | |
5950 } | |
5951 return result; | |
5952 } | |
5953 | |
5954 Request toRequest(String id) { | |
5955 return new Request(id, "edit.getRefactoring", toJson()); | |
5956 } | |
5957 | |
5958 @override | |
5959 String toString() => JSON.encode(toJson()); | |
5960 | |
5961 @override | |
5962 bool operator==(other) { | |
5963 if (other is EditGetRefactoringParams) { | |
5964 return kind == other.kind && | |
5965 file == other.file && | |
5966 offset == other.offset && | |
5967 length == other.length && | |
5968 validateOnly == other.validateOnly && | |
5969 options == other.options; | |
5970 } | |
5971 return false; | |
5972 } | |
5973 | |
5974 @override | |
5975 int get hashCode { | |
5976 int hash = 0; | |
5977 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
5978 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
5979 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
5980 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
5981 hash = _JenkinsSmiHash.combine(hash, validateOnly.hashCode); | |
5982 hash = _JenkinsSmiHash.combine(hash, options.hashCode); | |
5983 return _JenkinsSmiHash.finish(hash); | |
5984 } | |
5985 } | |
5986 | |
5987 /** | |
5988 * edit.getRefactoring result | |
5989 * | |
5990 * { | |
5991 * "initialProblems": List<RefactoringProblem> | |
5992 * "optionsProblems": List<RefactoringProblem> | |
5993 * "finalProblems": List<RefactoringProblem> | |
5994 * "feedback": optional RefactoringFeedback | |
5995 * "change": optional SourceChange | |
5996 * "potentialEdits": optional List<String> | |
5997 * } | |
5998 */ | |
5999 class EditGetRefactoringResult implements HasToJson { | |
6000 List<RefactoringProblem> _initialProblems; | |
6001 | |
6002 List<RefactoringProblem> _optionsProblems; | |
6003 | |
6004 List<RefactoringProblem> _finalProblems; | |
6005 | |
6006 RefactoringFeedback _feedback; | |
6007 | |
6008 SourceChange _change; | |
6009 | |
6010 List<String> _potentialEdits; | |
6011 | |
6012 /** | |
6013 * The initial status of the refactoring, i.e. problems related to the | |
6014 * context in which the refactoring is requested. The array will be empty if | |
6015 * there are no known problems. | |
6016 */ | |
6017 List<RefactoringProblem> get initialProblems => _initialProblems; | |
6018 | |
6019 /** | |
6020 * The initial status of the refactoring, i.e. problems related to the | |
6021 * context in which the refactoring is requested. The array will be empty if | |
6022 * there are no known problems. | |
6023 */ | |
6024 void set initialProblems(List<RefactoringProblem> value) { | |
6025 assert(value != null); | |
6026 this._initialProblems = value; | |
6027 } | |
6028 | |
6029 /** | |
6030 * The options validation status, i.e. problems in the given options, such as | |
6031 * light-weight validation of a new name, flags compatibility, etc. The array | |
6032 * will be empty if there are no known problems. | |
6033 */ | |
6034 List<RefactoringProblem> get optionsProblems => _optionsProblems; | |
6035 | |
6036 /** | |
6037 * The options validation status, i.e. problems in the given options, such as | |
6038 * light-weight validation of a new name, flags compatibility, etc. The array | |
6039 * will be empty if there are no known problems. | |
6040 */ | |
6041 void set optionsProblems(List<RefactoringProblem> value) { | |
6042 assert(value != null); | |
6043 this._optionsProblems = value; | |
6044 } | |
6045 | |
6046 /** | |
6047 * The final status of the refactoring, i.e. problems identified in the | |
6048 * result of a full, potentially expensive validation and / or change | |
6049 * creation. The array will be empty if there are no known problems. | |
6050 */ | |
6051 List<RefactoringProblem> get finalProblems => _finalProblems; | |
6052 | |
6053 /** | |
6054 * The final status of the refactoring, i.e. problems identified in the | |
6055 * result of a full, potentially expensive validation and / or change | |
6056 * creation. The array will be empty if there are no known problems. | |
6057 */ | |
6058 void set finalProblems(List<RefactoringProblem> value) { | |
6059 assert(value != null); | |
6060 this._finalProblems = value; | |
6061 } | |
6062 | |
6063 /** | |
6064 * Data used to provide feedback to the user. The structure of the data is | |
6065 * dependent on the kind of refactoring being created. The data that is | |
6066 * returned is documented in the section titled Refactorings, labeled as | |
6067 * “Feedback”. | |
6068 */ | |
6069 RefactoringFeedback get feedback => _feedback; | |
6070 | |
6071 /** | |
6072 * Data used to provide feedback to the user. The structure of the data is | |
6073 * dependent on the kind of refactoring being created. The data that is | |
6074 * returned is documented in the section titled Refactorings, labeled as | |
6075 * “Feedback”. | |
6076 */ | |
6077 void set feedback(RefactoringFeedback value) { | |
6078 this._feedback = value; | |
6079 } | |
6080 | |
6081 /** | |
6082 * The changes that are to be applied to affect the refactoring. This field | |
6083 * will be omitted if there are problems that prevent a set of changes from | |
6084 * being computed, such as having no options specified for a refactoring that | |
6085 * requires them, or if only validation was requested. | |
6086 */ | |
6087 SourceChange get change => _change; | |
6088 | |
6089 /** | |
6090 * The changes that are to be applied to affect the refactoring. This field | |
6091 * will be omitted if there are problems that prevent a set of changes from | |
6092 * being computed, such as having no options specified for a refactoring that | |
6093 * requires them, or if only validation was requested. | |
6094 */ | |
6095 void set change(SourceChange value) { | |
6096 this._change = value; | |
6097 } | |
6098 | |
6099 /** | |
6100 * The ids of source edits that are not known to be valid. An edit is not | |
6101 * known to be valid if there was insufficient type information for the | |
6102 * server to be able to determine whether or not the code needs to be | |
6103 * modified, such as when a member is being renamed and there is a reference | |
6104 * to a member from an unknown type. This field will be omitted if the change | |
6105 * field is omitted or if there are no potential edits for the refactoring. | |
6106 */ | |
6107 List<String> get potentialEdits => _potentialEdits; | |
6108 | |
6109 /** | |
6110 * The ids of source edits that are not known to be valid. An edit is not | |
6111 * known to be valid if there was insufficient type information for the | |
6112 * server to be able to determine whether or not the code needs to be | |
6113 * modified, such as when a member is being renamed and there is a reference | |
6114 * to a member from an unknown type. This field will be omitted if the change | |
6115 * field is omitted or if there are no potential edits for the refactoring. | |
6116 */ | |
6117 void set potentialEdits(List<String> value) { | |
6118 this._potentialEdits = value; | |
6119 } | |
6120 | |
6121 EditGetRefactoringResult(List<RefactoringProblem> initialProblems, List<Refact
oringProblem> optionsProblems, List<RefactoringProblem> finalProblems, {Refactor
ingFeedback feedback, SourceChange change, List<String> potentialEdits}) { | |
6122 this.initialProblems = initialProblems; | |
6123 this.optionsProblems = optionsProblems; | |
6124 this.finalProblems = finalProblems; | |
6125 this.feedback = feedback; | |
6126 this.change = change; | |
6127 this.potentialEdits = potentialEdits; | |
6128 } | |
6129 | |
6130 factory EditGetRefactoringResult.fromJson(JsonDecoder jsonDecoder, String json
Path, Object json) { | |
6131 if (json == null) { | |
6132 json = {}; | |
6133 } | |
6134 if (json is Map) { | |
6135 List<RefactoringProblem> initialProblems; | |
6136 if (json.containsKey("initialProblems")) { | |
6137 initialProblems = jsonDecoder._decodeList(jsonPath + ".initialProblems",
json["initialProblems"], (String jsonPath, Object json) => new RefactoringProbl
em.fromJson(jsonDecoder, jsonPath, json)); | |
6138 } else { | |
6139 throw jsonDecoder.missingKey(jsonPath, "initialProblems"); | |
6140 } | |
6141 List<RefactoringProblem> optionsProblems; | |
6142 if (json.containsKey("optionsProblems")) { | |
6143 optionsProblems = jsonDecoder._decodeList(jsonPath + ".optionsProblems",
json["optionsProblems"], (String jsonPath, Object json) => new RefactoringProbl
em.fromJson(jsonDecoder, jsonPath, json)); | |
6144 } else { | |
6145 throw jsonDecoder.missingKey(jsonPath, "optionsProblems"); | |
6146 } | |
6147 List<RefactoringProblem> finalProblems; | |
6148 if (json.containsKey("finalProblems")) { | |
6149 finalProblems = jsonDecoder._decodeList(jsonPath + ".finalProblems", jso
n["finalProblems"], (String jsonPath, Object json) => new RefactoringProblem.fro
mJson(jsonDecoder, jsonPath, json)); | |
6150 } else { | |
6151 throw jsonDecoder.missingKey(jsonPath, "finalProblems"); | |
6152 } | |
6153 RefactoringFeedback feedback; | |
6154 if (json.containsKey("feedback")) { | |
6155 feedback = new RefactoringFeedback.fromJson(jsonDecoder, jsonPath + ".fe
edback", json["feedback"], json); | |
6156 } | |
6157 SourceChange change; | |
6158 if (json.containsKey("change")) { | |
6159 change = new SourceChange.fromJson(jsonDecoder, jsonPath + ".change", js
on["change"]); | |
6160 } | |
6161 List<String> potentialEdits; | |
6162 if (json.containsKey("potentialEdits")) { | |
6163 potentialEdits = jsonDecoder._decodeList(jsonPath + ".potentialEdits", j
son["potentialEdits"], jsonDecoder._decodeString); | |
6164 } | |
6165 return new EditGetRefactoringResult(initialProblems, optionsProblems, fina
lProblems, feedback: feedback, change: change, potentialEdits: potentialEdits); | |
6166 } else { | |
6167 throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result", json); | |
6168 } | |
6169 } | |
6170 | |
6171 factory EditGetRefactoringResult.fromResponse(Response response) { | |
6172 return new EditGetRefactoringResult.fromJson( | |
6173 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
6174 } | |
6175 | |
6176 Map<String, dynamic> toJson() { | |
6177 Map<String, dynamic> result = {}; | |
6178 result["initialProblems"] = initialProblems.map((RefactoringProblem value) =
> value.toJson()).toList(); | |
6179 result["optionsProblems"] = optionsProblems.map((RefactoringProblem value) =
> value.toJson()).toList(); | |
6180 result["finalProblems"] = finalProblems.map((RefactoringProblem value) => va
lue.toJson()).toList(); | |
6181 if (feedback != null) { | |
6182 result["feedback"] = feedback.toJson(); | |
6183 } | |
6184 if (change != null) { | |
6185 result["change"] = change.toJson(); | |
6186 } | |
6187 if (potentialEdits != null) { | |
6188 result["potentialEdits"] = potentialEdits; | |
6189 } | |
6190 return result; | |
6191 } | |
6192 | |
6193 Response toResponse(String id) { | |
6194 return new Response(id, result: toJson()); | |
6195 } | |
6196 | |
6197 @override | |
6198 String toString() => JSON.encode(toJson()); | |
6199 | |
6200 @override | |
6201 bool operator==(other) { | |
6202 if (other is EditGetRefactoringResult) { | |
6203 return _listEqual(initialProblems, other.initialProblems, (RefactoringProb
lem a, RefactoringProblem b) => a == b) && | |
6204 _listEqual(optionsProblems, other.optionsProblems, (RefactoringProblem
a, RefactoringProblem b) => a == b) && | |
6205 _listEqual(finalProblems, other.finalProblems, (RefactoringProblem a,
RefactoringProblem b) => a == b) && | |
6206 feedback == other.feedback && | |
6207 change == other.change && | |
6208 _listEqual(potentialEdits, other.potentialEdits, (String a, String b)
=> a == b); | |
6209 } | |
6210 return false; | |
6211 } | |
6212 | |
6213 @override | |
6214 int get hashCode { | |
6215 int hash = 0; | |
6216 hash = _JenkinsSmiHash.combine(hash, initialProblems.hashCode); | |
6217 hash = _JenkinsSmiHash.combine(hash, optionsProblems.hashCode); | |
6218 hash = _JenkinsSmiHash.combine(hash, finalProblems.hashCode); | |
6219 hash = _JenkinsSmiHash.combine(hash, feedback.hashCode); | |
6220 hash = _JenkinsSmiHash.combine(hash, change.hashCode); | |
6221 hash = _JenkinsSmiHash.combine(hash, potentialEdits.hashCode); | |
6222 return _JenkinsSmiHash.finish(hash); | |
6223 } | |
6224 } | |
6225 | |
6226 /** | |
6227 * edit.sortMembers params | |
6228 * | |
6229 * { | |
6230 * "file": FilePath | |
6231 * } | |
6232 */ | |
6233 class EditSortMembersParams implements HasToJson { | |
6234 String _file; | |
6235 | |
6236 /** | |
6237 * The Dart file to sort. | |
6238 */ | |
6239 String get file => _file; | |
6240 | |
6241 /** | |
6242 * The Dart file to sort. | |
6243 */ | |
6244 void set file(String value) { | |
6245 assert(value != null); | |
6246 this._file = value; | |
6247 } | |
6248 | |
6249 EditSortMembersParams(String file) { | |
6250 this.file = file; | |
6251 } | |
6252 | |
6253 factory EditSortMembersParams.fromJson(JsonDecoder jsonDecoder, String jsonPat
h, Object json) { | |
6254 if (json == null) { | |
6255 json = {}; | |
6256 } | |
6257 if (json is Map) { | |
6258 String file; | |
6259 if (json.containsKey("file")) { | |
6260 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
6261 } else { | |
6262 throw jsonDecoder.missingKey(jsonPath, "file"); | |
6263 } | |
6264 return new EditSortMembersParams(file); | |
6265 } else { | |
6266 throw jsonDecoder.mismatch(jsonPath, "edit.sortMembers params", json); | |
6267 } | |
6268 } | |
6269 | |
6270 factory EditSortMembersParams.fromRequest(Request request) { | |
6271 return new EditSortMembersParams.fromJson( | |
6272 new RequestDecoder(request), "params", request._params); | |
6273 } | |
6274 | |
6275 Map<String, dynamic> toJson() { | |
6276 Map<String, dynamic> result = {}; | |
6277 result["file"] = file; | |
6278 return result; | |
6279 } | |
6280 | |
6281 Request toRequest(String id) { | |
6282 return new Request(id, "edit.sortMembers", toJson()); | |
6283 } | |
6284 | |
6285 @override | |
6286 String toString() => JSON.encode(toJson()); | |
6287 | |
6288 @override | |
6289 bool operator==(other) { | |
6290 if (other is EditSortMembersParams) { | |
6291 return file == other.file; | |
6292 } | |
6293 return false; | |
6294 } | |
6295 | |
6296 @override | |
6297 int get hashCode { | |
6298 int hash = 0; | |
6299 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
6300 return _JenkinsSmiHash.finish(hash); | |
6301 } | |
6302 } | |
6303 | |
6304 /** | |
6305 * edit.sortMembers result | |
6306 * | |
6307 * { | |
6308 * "edit": SourceFileEdit | |
6309 * } | |
6310 */ | |
6311 class EditSortMembersResult implements HasToJson { | |
6312 SourceFileEdit _edit; | |
6313 | |
6314 /** | |
6315 * The file edit that is to be applied to the given file to effect the | |
6316 * sorting. | |
6317 */ | |
6318 SourceFileEdit get edit => _edit; | |
6319 | |
6320 /** | |
6321 * The file edit that is to be applied to the given file to effect the | |
6322 * sorting. | |
6323 */ | |
6324 void set edit(SourceFileEdit value) { | |
6325 assert(value != null); | |
6326 this._edit = value; | |
6327 } | |
6328 | |
6329 EditSortMembersResult(SourceFileEdit edit) { | |
6330 this.edit = edit; | |
6331 } | |
6332 | |
6333 factory EditSortMembersResult.fromJson(JsonDecoder jsonDecoder, String jsonPat
h, Object json) { | |
6334 if (json == null) { | |
6335 json = {}; | |
6336 } | |
6337 if (json is Map) { | |
6338 SourceFileEdit edit; | |
6339 if (json.containsKey("edit")) { | |
6340 edit = new SourceFileEdit.fromJson(jsonDecoder, jsonPath + ".edit", json
["edit"]); | |
6341 } else { | |
6342 throw jsonDecoder.missingKey(jsonPath, "edit"); | |
6343 } | |
6344 return new EditSortMembersResult(edit); | |
6345 } else { | |
6346 throw jsonDecoder.mismatch(jsonPath, "edit.sortMembers result", json); | |
6347 } | |
6348 } | |
6349 | |
6350 factory EditSortMembersResult.fromResponse(Response response) { | |
6351 return new EditSortMembersResult.fromJson( | |
6352 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
6353 } | |
6354 | |
6355 Map<String, dynamic> toJson() { | |
6356 Map<String, dynamic> result = {}; | |
6357 result["edit"] = edit.toJson(); | |
6358 return result; | |
6359 } | |
6360 | |
6361 Response toResponse(String id) { | |
6362 return new Response(id, result: toJson()); | |
6363 } | |
6364 | |
6365 @override | |
6366 String toString() => JSON.encode(toJson()); | |
6367 | |
6368 @override | |
6369 bool operator==(other) { | |
6370 if (other is EditSortMembersResult) { | |
6371 return edit == other.edit; | |
6372 } | |
6373 return false; | |
6374 } | |
6375 | |
6376 @override | |
6377 int get hashCode { | |
6378 int hash = 0; | |
6379 hash = _JenkinsSmiHash.combine(hash, edit.hashCode); | |
6380 return _JenkinsSmiHash.finish(hash); | |
6381 } | |
6382 } | |
6383 | |
6384 /** | |
6385 * edit.organizeDirectives params | |
6386 * | |
6387 * { | |
6388 * "file": FilePath | |
6389 * } | |
6390 */ | |
6391 class EditOrganizeDirectivesParams implements HasToJson { | |
6392 String _file; | |
6393 | |
6394 /** | |
6395 * The Dart file to organize directives in. | |
6396 */ | |
6397 String get file => _file; | |
6398 | |
6399 /** | |
6400 * The Dart file to organize directives in. | |
6401 */ | |
6402 void set file(String value) { | |
6403 assert(value != null); | |
6404 this._file = value; | |
6405 } | |
6406 | |
6407 EditOrganizeDirectivesParams(String file) { | |
6408 this.file = file; | |
6409 } | |
6410 | |
6411 factory EditOrganizeDirectivesParams.fromJson(JsonDecoder jsonDecoder, String
jsonPath, Object json) { | |
6412 if (json == null) { | |
6413 json = {}; | |
6414 } | |
6415 if (json is Map) { | |
6416 String file; | |
6417 if (json.containsKey("file")) { | |
6418 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
6419 } else { | |
6420 throw jsonDecoder.missingKey(jsonPath, "file"); | |
6421 } | |
6422 return new EditOrganizeDirectivesParams(file); | |
6423 } else { | |
6424 throw jsonDecoder.mismatch(jsonPath, "edit.organizeDirectives params", jso
n); | |
6425 } | |
6426 } | |
6427 | |
6428 factory EditOrganizeDirectivesParams.fromRequest(Request request) { | |
6429 return new EditOrganizeDirectivesParams.fromJson( | |
6430 new RequestDecoder(request), "params", request._params); | |
6431 } | |
6432 | |
6433 Map<String, dynamic> toJson() { | |
6434 Map<String, dynamic> result = {}; | |
6435 result["file"] = file; | |
6436 return result; | |
6437 } | |
6438 | |
6439 Request toRequest(String id) { | |
6440 return new Request(id, "edit.organizeDirectives", toJson()); | |
6441 } | |
6442 | |
6443 @override | |
6444 String toString() => JSON.encode(toJson()); | |
6445 | |
6446 @override | |
6447 bool operator==(other) { | |
6448 if (other is EditOrganizeDirectivesParams) { | |
6449 return file == other.file; | |
6450 } | |
6451 return false; | |
6452 } | |
6453 | |
6454 @override | |
6455 int get hashCode { | |
6456 int hash = 0; | |
6457 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
6458 return _JenkinsSmiHash.finish(hash); | |
6459 } | |
6460 } | |
6461 | |
6462 /** | |
6463 * edit.organizeDirectives result | |
6464 * | |
6465 * { | |
6466 * "edit": SourceFileEdit | |
6467 * } | |
6468 */ | |
6469 class EditOrganizeDirectivesResult implements HasToJson { | |
6470 SourceFileEdit _edit; | |
6471 | |
6472 /** | |
6473 * The file edit that is to be applied to the given file to effect the | |
6474 * organizing. | |
6475 */ | |
6476 SourceFileEdit get edit => _edit; | |
6477 | |
6478 /** | |
6479 * The file edit that is to be applied to the given file to effect the | |
6480 * organizing. | |
6481 */ | |
6482 void set edit(SourceFileEdit value) { | |
6483 assert(value != null); | |
6484 this._edit = value; | |
6485 } | |
6486 | |
6487 EditOrganizeDirectivesResult(SourceFileEdit edit) { | |
6488 this.edit = edit; | |
6489 } | |
6490 | |
6491 factory EditOrganizeDirectivesResult.fromJson(JsonDecoder jsonDecoder, String
jsonPath, Object json) { | |
6492 if (json == null) { | |
6493 json = {}; | |
6494 } | |
6495 if (json is Map) { | |
6496 SourceFileEdit edit; | |
6497 if (json.containsKey("edit")) { | |
6498 edit = new SourceFileEdit.fromJson(jsonDecoder, jsonPath + ".edit", json
["edit"]); | |
6499 } else { | |
6500 throw jsonDecoder.missingKey(jsonPath, "edit"); | |
6501 } | |
6502 return new EditOrganizeDirectivesResult(edit); | |
6503 } else { | |
6504 throw jsonDecoder.mismatch(jsonPath, "edit.organizeDirectives result", jso
n); | |
6505 } | |
6506 } | |
6507 | |
6508 factory EditOrganizeDirectivesResult.fromResponse(Response response) { | |
6509 return new EditOrganizeDirectivesResult.fromJson( | |
6510 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
6511 } | |
6512 | |
6513 Map<String, dynamic> toJson() { | |
6514 Map<String, dynamic> result = {}; | |
6515 result["edit"] = edit.toJson(); | |
6516 return result; | |
6517 } | |
6518 | |
6519 Response toResponse(String id) { | |
6520 return new Response(id, result: toJson()); | |
6521 } | |
6522 | |
6523 @override | |
6524 String toString() => JSON.encode(toJson()); | |
6525 | |
6526 @override | |
6527 bool operator==(other) { | |
6528 if (other is EditOrganizeDirectivesResult) { | |
6529 return edit == other.edit; | |
6530 } | |
6531 return false; | |
6532 } | |
6533 | |
6534 @override | |
6535 int get hashCode { | |
6536 int hash = 0; | |
6537 hash = _JenkinsSmiHash.combine(hash, edit.hashCode); | |
6538 return _JenkinsSmiHash.finish(hash); | |
6539 } | |
6540 } | |
6541 | |
6542 /** | |
6543 * execution.createContext params | |
6544 * | |
6545 * { | |
6546 * "contextRoot": FilePath | |
6547 * } | |
6548 */ | |
6549 class ExecutionCreateContextParams implements HasToJson { | |
6550 String _contextRoot; | |
6551 | |
6552 /** | |
6553 * The path of the Dart or HTML file that will be launched, or the path of | |
6554 * the directory containing the file. | |
6555 */ | |
6556 String get contextRoot => _contextRoot; | |
6557 | |
6558 /** | |
6559 * The path of the Dart or HTML file that will be launched, or the path of | |
6560 * the directory containing the file. | |
6561 */ | |
6562 void set contextRoot(String value) { | |
6563 assert(value != null); | |
6564 this._contextRoot = value; | |
6565 } | |
6566 | |
6567 ExecutionCreateContextParams(String contextRoot) { | |
6568 this.contextRoot = contextRoot; | |
6569 } | |
6570 | |
6571 factory ExecutionCreateContextParams.fromJson(JsonDecoder jsonDecoder, String
jsonPath, Object json) { | |
6572 if (json == null) { | |
6573 json = {}; | |
6574 } | |
6575 if (json is Map) { | |
6576 String contextRoot; | |
6577 if (json.containsKey("contextRoot")) { | |
6578 contextRoot = jsonDecoder._decodeString(jsonPath + ".contextRoot", json[
"contextRoot"]); | |
6579 } else { | |
6580 throw jsonDecoder.missingKey(jsonPath, "contextRoot"); | |
6581 } | |
6582 return new ExecutionCreateContextParams(contextRoot); | |
6583 } else { | |
6584 throw jsonDecoder.mismatch(jsonPath, "execution.createContext params", jso
n); | |
6585 } | |
6586 } | |
6587 | |
6588 factory ExecutionCreateContextParams.fromRequest(Request request) { | |
6589 return new ExecutionCreateContextParams.fromJson( | |
6590 new RequestDecoder(request), "params", request._params); | |
6591 } | |
6592 | |
6593 Map<String, dynamic> toJson() { | |
6594 Map<String, dynamic> result = {}; | |
6595 result["contextRoot"] = contextRoot; | |
6596 return result; | |
6597 } | |
6598 | |
6599 Request toRequest(String id) { | |
6600 return new Request(id, "execution.createContext", toJson()); | |
6601 } | |
6602 | |
6603 @override | |
6604 String toString() => JSON.encode(toJson()); | |
6605 | |
6606 @override | |
6607 bool operator==(other) { | |
6608 if (other is ExecutionCreateContextParams) { | |
6609 return contextRoot == other.contextRoot; | |
6610 } | |
6611 return false; | |
6612 } | |
6613 | |
6614 @override | |
6615 int get hashCode { | |
6616 int hash = 0; | |
6617 hash = _JenkinsSmiHash.combine(hash, contextRoot.hashCode); | |
6618 return _JenkinsSmiHash.finish(hash); | |
6619 } | |
6620 } | |
6621 | |
6622 /** | |
6623 * execution.createContext result | |
6624 * | |
6625 * { | |
6626 * "id": ExecutionContextId | |
6627 * } | |
6628 */ | |
6629 class ExecutionCreateContextResult implements HasToJson { | |
6630 String _id; | |
6631 | |
6632 /** | |
6633 * The identifier used to refer to the execution context that was created. | |
6634 */ | |
6635 String get id => _id; | |
6636 | |
6637 /** | |
6638 * The identifier used to refer to the execution context that was created. | |
6639 */ | |
6640 void set id(String value) { | |
6641 assert(value != null); | |
6642 this._id = value; | |
6643 } | |
6644 | |
6645 ExecutionCreateContextResult(String id) { | |
6646 this.id = id; | |
6647 } | |
6648 | |
6649 factory ExecutionCreateContextResult.fromJson(JsonDecoder jsonDecoder, String
jsonPath, Object json) { | |
6650 if (json == null) { | |
6651 json = {}; | |
6652 } | |
6653 if (json is Map) { | |
6654 String id; | |
6655 if (json.containsKey("id")) { | |
6656 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
6657 } else { | |
6658 throw jsonDecoder.missingKey(jsonPath, "id"); | |
6659 } | |
6660 return new ExecutionCreateContextResult(id); | |
6661 } else { | |
6662 throw jsonDecoder.mismatch(jsonPath, "execution.createContext result", jso
n); | |
6663 } | |
6664 } | |
6665 | |
6666 factory ExecutionCreateContextResult.fromResponse(Response response) { | |
6667 return new ExecutionCreateContextResult.fromJson( | |
6668 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
6669 } | |
6670 | |
6671 Map<String, dynamic> toJson() { | |
6672 Map<String, dynamic> result = {}; | |
6673 result["id"] = id; | |
6674 return result; | |
6675 } | |
6676 | |
6677 Response toResponse(String id) { | |
6678 return new Response(id, result: toJson()); | |
6679 } | |
6680 | |
6681 @override | |
6682 String toString() => JSON.encode(toJson()); | |
6683 | |
6684 @override | |
6685 bool operator==(other) { | |
6686 if (other is ExecutionCreateContextResult) { | |
6687 return id == other.id; | |
6688 } | |
6689 return false; | |
6690 } | |
6691 | |
6692 @override | |
6693 int get hashCode { | |
6694 int hash = 0; | |
6695 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
6696 return _JenkinsSmiHash.finish(hash); | |
6697 } | |
6698 } | |
6699 | |
6700 /** | |
6701 * execution.deleteContext params | |
6702 * | |
6703 * { | |
6704 * "id": ExecutionContextId | |
6705 * } | |
6706 */ | |
6707 class ExecutionDeleteContextParams implements HasToJson { | |
6708 String _id; | |
6709 | |
6710 /** | |
6711 * The identifier of the execution context that is to be deleted. | |
6712 */ | |
6713 String get id => _id; | |
6714 | |
6715 /** | |
6716 * The identifier of the execution context that is to be deleted. | |
6717 */ | |
6718 void set id(String value) { | |
6719 assert(value != null); | |
6720 this._id = value; | |
6721 } | |
6722 | |
6723 ExecutionDeleteContextParams(String id) { | |
6724 this.id = id; | |
6725 } | |
6726 | |
6727 factory ExecutionDeleteContextParams.fromJson(JsonDecoder jsonDecoder, String
jsonPath, Object json) { | |
6728 if (json == null) { | |
6729 json = {}; | |
6730 } | |
6731 if (json is Map) { | |
6732 String id; | |
6733 if (json.containsKey("id")) { | |
6734 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
6735 } else { | |
6736 throw jsonDecoder.missingKey(jsonPath, "id"); | |
6737 } | |
6738 return new ExecutionDeleteContextParams(id); | |
6739 } else { | |
6740 throw jsonDecoder.mismatch(jsonPath, "execution.deleteContext params", jso
n); | |
6741 } | |
6742 } | |
6743 | |
6744 factory ExecutionDeleteContextParams.fromRequest(Request request) { | |
6745 return new ExecutionDeleteContextParams.fromJson( | |
6746 new RequestDecoder(request), "params", request._params); | |
6747 } | |
6748 | |
6749 Map<String, dynamic> toJson() { | |
6750 Map<String, dynamic> result = {}; | |
6751 result["id"] = id; | |
6752 return result; | |
6753 } | |
6754 | |
6755 Request toRequest(String id) { | |
6756 return new Request(id, "execution.deleteContext", toJson()); | |
6757 } | |
6758 | |
6759 @override | |
6760 String toString() => JSON.encode(toJson()); | |
6761 | |
6762 @override | |
6763 bool operator==(other) { | |
6764 if (other is ExecutionDeleteContextParams) { | |
6765 return id == other.id; | |
6766 } | |
6767 return false; | |
6768 } | |
6769 | |
6770 @override | |
6771 int get hashCode { | |
6772 int hash = 0; | |
6773 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
6774 return _JenkinsSmiHash.finish(hash); | |
6775 } | |
6776 } | |
6777 /** | |
6778 * execution.deleteContext result | |
6779 */ | |
6780 class ExecutionDeleteContextResult { | |
6781 Response toResponse(String id) { | |
6782 return new Response(id, result: null); | |
6783 } | |
6784 | |
6785 @override | |
6786 bool operator==(other) { | |
6787 if (other is ExecutionDeleteContextResult) { | |
6788 return true; | |
6789 } | |
6790 return false; | |
6791 } | |
6792 | |
6793 @override | |
6794 int get hashCode { | |
6795 return 479954425; | |
6796 } | |
6797 } | |
6798 | |
6799 /** | |
6800 * execution.mapUri params | |
6801 * | |
6802 * { | |
6803 * "id": ExecutionContextId | |
6804 * "file": optional FilePath | |
6805 * "uri": optional String | |
6806 * } | |
6807 */ | |
6808 class ExecutionMapUriParams implements HasToJson { | |
6809 String _id; | |
6810 | |
6811 String _file; | |
6812 | |
6813 String _uri; | |
6814 | |
6815 /** | |
6816 * The identifier of the execution context in which the URI is to be mapped. | |
6817 */ | |
6818 String get id => _id; | |
6819 | |
6820 /** | |
6821 * The identifier of the execution context in which the URI is to be mapped. | |
6822 */ | |
6823 void set id(String value) { | |
6824 assert(value != null); | |
6825 this._id = value; | |
6826 } | |
6827 | |
6828 /** | |
6829 * The path of the file to be mapped into a URI. | |
6830 */ | |
6831 String get file => _file; | |
6832 | |
6833 /** | |
6834 * The path of the file to be mapped into a URI. | |
6835 */ | |
6836 void set file(String value) { | |
6837 this._file = value; | |
6838 } | |
6839 | |
6840 /** | |
6841 * The URI to be mapped into a file path. | |
6842 */ | |
6843 String get uri => _uri; | |
6844 | |
6845 /** | |
6846 * The URI to be mapped into a file path. | |
6847 */ | |
6848 void set uri(String value) { | |
6849 this._uri = value; | |
6850 } | |
6851 | |
6852 ExecutionMapUriParams(String id, {String file, String uri}) { | |
6853 this.id = id; | |
6854 this.file = file; | |
6855 this.uri = uri; | |
6856 } | |
6857 | |
6858 factory ExecutionMapUriParams.fromJson(JsonDecoder jsonDecoder, String jsonPat
h, Object json) { | |
6859 if (json == null) { | |
6860 json = {}; | |
6861 } | |
6862 if (json is Map) { | |
6863 String id; | |
6864 if (json.containsKey("id")) { | |
6865 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
6866 } else { | |
6867 throw jsonDecoder.missingKey(jsonPath, "id"); | |
6868 } | |
6869 String file; | |
6870 if (json.containsKey("file")) { | |
6871 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
6872 } | |
6873 String uri; | |
6874 if (json.containsKey("uri")) { | |
6875 uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]); | |
6876 } | |
6877 return new ExecutionMapUriParams(id, file: file, uri: uri); | |
6878 } else { | |
6879 throw jsonDecoder.mismatch(jsonPath, "execution.mapUri params", json); | |
6880 } | |
6881 } | |
6882 | |
6883 factory ExecutionMapUriParams.fromRequest(Request request) { | |
6884 return new ExecutionMapUriParams.fromJson( | |
6885 new RequestDecoder(request), "params", request._params); | |
6886 } | |
6887 | |
6888 Map<String, dynamic> toJson() { | |
6889 Map<String, dynamic> result = {}; | |
6890 result["id"] = id; | |
6891 if (file != null) { | |
6892 result["file"] = file; | |
6893 } | |
6894 if (uri != null) { | |
6895 result["uri"] = uri; | |
6896 } | |
6897 return result; | |
6898 } | |
6899 | |
6900 Request toRequest(String id) { | |
6901 return new Request(id, "execution.mapUri", toJson()); | |
6902 } | |
6903 | |
6904 @override | |
6905 String toString() => JSON.encode(toJson()); | |
6906 | |
6907 @override | |
6908 bool operator==(other) { | |
6909 if (other is ExecutionMapUriParams) { | |
6910 return id == other.id && | |
6911 file == other.file && | |
6912 uri == other.uri; | |
6913 } | |
6914 return false; | |
6915 } | |
6916 | |
6917 @override | |
6918 int get hashCode { | |
6919 int hash = 0; | |
6920 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
6921 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
6922 hash = _JenkinsSmiHash.combine(hash, uri.hashCode); | |
6923 return _JenkinsSmiHash.finish(hash); | |
6924 } | |
6925 } | |
6926 | |
6927 /** | |
6928 * execution.mapUri result | |
6929 * | |
6930 * { | |
6931 * "file": optional FilePath | |
6932 * "uri": optional String | |
6933 * } | |
6934 */ | |
6935 class ExecutionMapUriResult implements HasToJson { | |
6936 String _file; | |
6937 | |
6938 String _uri; | |
6939 | |
6940 /** | |
6941 * The file to which the URI was mapped. This field is omitted if the uri | |
6942 * field was not given in the request. | |
6943 */ | |
6944 String get file => _file; | |
6945 | |
6946 /** | |
6947 * The file to which the URI was mapped. This field is omitted if the uri | |
6948 * field was not given in the request. | |
6949 */ | |
6950 void set file(String value) { | |
6951 this._file = value; | |
6952 } | |
6953 | |
6954 /** | |
6955 * The URI to which the file path was mapped. This field is omitted if the | |
6956 * file field was not given in the request. | |
6957 */ | |
6958 String get uri => _uri; | |
6959 | |
6960 /** | |
6961 * The URI to which the file path was mapped. This field is omitted if the | |
6962 * file field was not given in the request. | |
6963 */ | |
6964 void set uri(String value) { | |
6965 this._uri = value; | |
6966 } | |
6967 | |
6968 ExecutionMapUriResult({String file, String uri}) { | |
6969 this.file = file; | |
6970 this.uri = uri; | |
6971 } | |
6972 | |
6973 factory ExecutionMapUriResult.fromJson(JsonDecoder jsonDecoder, String jsonPat
h, Object json) { | |
6974 if (json == null) { | |
6975 json = {}; | |
6976 } | |
6977 if (json is Map) { | |
6978 String file; | |
6979 if (json.containsKey("file")) { | |
6980 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
6981 } | |
6982 String uri; | |
6983 if (json.containsKey("uri")) { | |
6984 uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]); | |
6985 } | |
6986 return new ExecutionMapUriResult(file: file, uri: uri); | |
6987 } else { | |
6988 throw jsonDecoder.mismatch(jsonPath, "execution.mapUri result", json); | |
6989 } | |
6990 } | |
6991 | |
6992 factory ExecutionMapUriResult.fromResponse(Response response) { | |
6993 return new ExecutionMapUriResult.fromJson( | |
6994 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "
result", response._result); | |
6995 } | |
6996 | |
6997 Map<String, dynamic> toJson() { | |
6998 Map<String, dynamic> result = {}; | |
6999 if (file != null) { | |
7000 result["file"] = file; | |
7001 } | |
7002 if (uri != null) { | |
7003 result["uri"] = uri; | |
7004 } | |
7005 return result; | |
7006 } | |
7007 | |
7008 Response toResponse(String id) { | |
7009 return new Response(id, result: toJson()); | |
7010 } | |
7011 | |
7012 @override | |
7013 String toString() => JSON.encode(toJson()); | |
7014 | |
7015 @override | |
7016 bool operator==(other) { | |
7017 if (other is ExecutionMapUriResult) { | |
7018 return file == other.file && | |
7019 uri == other.uri; | |
7020 } | |
7021 return false; | |
7022 } | |
7023 | |
7024 @override | |
7025 int get hashCode { | |
7026 int hash = 0; | |
7027 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
7028 hash = _JenkinsSmiHash.combine(hash, uri.hashCode); | |
7029 return _JenkinsSmiHash.finish(hash); | |
7030 } | |
7031 } | |
7032 | |
7033 /** | |
7034 * execution.setSubscriptions params | |
7035 * | |
7036 * { | |
7037 * "subscriptions": List<ExecutionService> | |
7038 * } | |
7039 */ | |
7040 class ExecutionSetSubscriptionsParams implements HasToJson { | |
7041 List<ExecutionService> _subscriptions; | |
7042 | |
7043 /** | |
7044 * A list of the services being subscribed to. | |
7045 */ | |
7046 List<ExecutionService> get subscriptions => _subscriptions; | |
7047 | |
7048 /** | |
7049 * A list of the services being subscribed to. | |
7050 */ | |
7051 void set subscriptions(List<ExecutionService> value) { | |
7052 assert(value != null); | |
7053 this._subscriptions = value; | |
7054 } | |
7055 | |
7056 ExecutionSetSubscriptionsParams(List<ExecutionService> subscriptions) { | |
7057 this.subscriptions = subscriptions; | |
7058 } | |
7059 | |
7060 factory ExecutionSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, Stri
ng jsonPath, Object json) { | |
7061 if (json == null) { | |
7062 json = {}; | |
7063 } | |
7064 if (json is Map) { | |
7065 List<ExecutionService> subscriptions; | |
7066 if (json.containsKey("subscriptions")) { | |
7067 subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", jso
n["subscriptions"], (String jsonPath, Object json) => new ExecutionService.fromJ
son(jsonDecoder, jsonPath, json)); | |
7068 } else { | |
7069 throw jsonDecoder.missingKey(jsonPath, "subscriptions"); | |
7070 } | |
7071 return new ExecutionSetSubscriptionsParams(subscriptions); | |
7072 } else { | |
7073 throw jsonDecoder.mismatch(jsonPath, "execution.setSubscriptions params",
json); | |
7074 } | |
7075 } | |
7076 | |
7077 factory ExecutionSetSubscriptionsParams.fromRequest(Request request) { | |
7078 return new ExecutionSetSubscriptionsParams.fromJson( | |
7079 new RequestDecoder(request), "params", request._params); | |
7080 } | |
7081 | |
7082 Map<String, dynamic> toJson() { | |
7083 Map<String, dynamic> result = {}; | |
7084 result["subscriptions"] = subscriptions.map((ExecutionService value) => valu
e.toJson()).toList(); | |
7085 return result; | |
7086 } | |
7087 | |
7088 Request toRequest(String id) { | |
7089 return new Request(id, "execution.setSubscriptions", toJson()); | |
7090 } | |
7091 | |
7092 @override | |
7093 String toString() => JSON.encode(toJson()); | |
7094 | |
7095 @override | |
7096 bool operator==(other) { | |
7097 if (other is ExecutionSetSubscriptionsParams) { | |
7098 return _listEqual(subscriptions, other.subscriptions, (ExecutionService a,
ExecutionService b) => a == b); | |
7099 } | |
7100 return false; | |
7101 } | |
7102 | |
7103 @override | |
7104 int get hashCode { | |
7105 int hash = 0; | |
7106 hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode); | |
7107 return _JenkinsSmiHash.finish(hash); | |
7108 } | |
7109 } | |
7110 /** | |
7111 * execution.setSubscriptions result | |
7112 */ | |
7113 class ExecutionSetSubscriptionsResult { | |
7114 Response toResponse(String id) { | |
7115 return new Response(id, result: null); | |
7116 } | |
7117 | |
7118 @override | |
7119 bool operator==(other) { | |
7120 if (other is ExecutionSetSubscriptionsResult) { | |
7121 return true; | |
7122 } | |
7123 return false; | |
7124 } | |
7125 | |
7126 @override | |
7127 int get hashCode { | |
7128 return 287678780; | |
7129 } | |
7130 } | |
7131 | |
7132 /** | |
7133 * execution.launchData params | |
7134 * | |
7135 * { | |
7136 * "file": FilePath | |
7137 * "kind": optional ExecutableKind | |
7138 * "referencedFiles": optional List<FilePath> | |
7139 * } | |
7140 */ | |
7141 class ExecutionLaunchDataParams implements HasToJson { | |
7142 String _file; | |
7143 | |
7144 ExecutableKind _kind; | |
7145 | |
7146 List<String> _referencedFiles; | |
7147 | |
7148 /** | |
7149 * The file for which launch data is being provided. This will either be a | |
7150 * Dart library or an HTML file. | |
7151 */ | |
7152 String get file => _file; | |
7153 | |
7154 /** | |
7155 * The file for which launch data is being provided. This will either be a | |
7156 * Dart library or an HTML file. | |
7157 */ | |
7158 void set file(String value) { | |
7159 assert(value != null); | |
7160 this._file = value; | |
7161 } | |
7162 | |
7163 /** | |
7164 * The kind of the executable file. This field is omitted if the file is not | |
7165 * a Dart file. | |
7166 */ | |
7167 ExecutableKind get kind => _kind; | |
7168 | |
7169 /** | |
7170 * The kind of the executable file. This field is omitted if the file is not | |
7171 * a Dart file. | |
7172 */ | |
7173 void set kind(ExecutableKind value) { | |
7174 this._kind = value; | |
7175 } | |
7176 | |
7177 /** | |
7178 * A list of the Dart files that are referenced by the file. This field is | |
7179 * omitted if the file is not an HTML file. | |
7180 */ | |
7181 List<String> get referencedFiles => _referencedFiles; | |
7182 | |
7183 /** | |
7184 * A list of the Dart files that are referenced by the file. This field is | |
7185 * omitted if the file is not an HTML file. | |
7186 */ | |
7187 void set referencedFiles(List<String> value) { | |
7188 this._referencedFiles = value; | |
7189 } | |
7190 | |
7191 ExecutionLaunchDataParams(String file, {ExecutableKind kind, List<String> refe
rencedFiles}) { | |
7192 this.file = file; | |
7193 this.kind = kind; | |
7194 this.referencedFiles = referencedFiles; | |
7195 } | |
7196 | |
7197 factory ExecutionLaunchDataParams.fromJson(JsonDecoder jsonDecoder, String jso
nPath, Object json) { | |
7198 if (json == null) { | |
7199 json = {}; | |
7200 } | |
7201 if (json is Map) { | |
7202 String file; | |
7203 if (json.containsKey("file")) { | |
7204 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
7205 } else { | |
7206 throw jsonDecoder.missingKey(jsonPath, "file"); | |
7207 } | |
7208 ExecutableKind kind; | |
7209 if (json.containsKey("kind")) { | |
7210 kind = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".kind", json
["kind"]); | |
7211 } | |
7212 List<String> referencedFiles; | |
7213 if (json.containsKey("referencedFiles")) { | |
7214 referencedFiles = jsonDecoder._decodeList(jsonPath + ".referencedFiles",
json["referencedFiles"], jsonDecoder._decodeString); | |
7215 } | |
7216 return new ExecutionLaunchDataParams(file, kind: kind, referencedFiles: re
ferencedFiles); | |
7217 } else { | |
7218 throw jsonDecoder.mismatch(jsonPath, "execution.launchData params", json); | |
7219 } | |
7220 } | |
7221 | |
7222 factory ExecutionLaunchDataParams.fromNotification(Notification notification)
{ | |
7223 return new ExecutionLaunchDataParams.fromJson( | |
7224 new ResponseDecoder(null), "params", notification._params); | |
7225 } | |
7226 | |
7227 Map<String, dynamic> toJson() { | |
7228 Map<String, dynamic> result = {}; | |
7229 result["file"] = file; | |
7230 if (kind != null) { | |
7231 result["kind"] = kind.toJson(); | |
7232 } | |
7233 if (referencedFiles != null) { | |
7234 result["referencedFiles"] = referencedFiles; | |
7235 } | |
7236 return result; | |
7237 } | |
7238 | |
7239 Notification toNotification() { | |
7240 return new Notification("execution.launchData", toJson()); | |
7241 } | |
7242 | |
7243 @override | |
7244 String toString() => JSON.encode(toJson()); | |
7245 | |
7246 @override | |
7247 bool operator==(other) { | |
7248 if (other is ExecutionLaunchDataParams) { | |
7249 return file == other.file && | |
7250 kind == other.kind && | |
7251 _listEqual(referencedFiles, other.referencedFiles, (String a, String b
) => a == b); | |
7252 } | |
7253 return false; | |
7254 } | |
7255 | |
7256 @override | |
7257 int get hashCode { | |
7258 int hash = 0; | |
7259 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
7260 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
7261 hash = _JenkinsSmiHash.combine(hash, referencedFiles.hashCode); | |
7262 return _JenkinsSmiHash.finish(hash); | |
7263 } | |
7264 } | |
7265 | |
7266 /** | |
7267 * AddContentOverlay | |
7268 * | |
7269 * { | |
7270 * "type": "add" | |
7271 * "content": String | |
7272 * } | |
7273 */ | |
7274 class AddContentOverlay implements HasToJson { | |
7275 String _content; | |
7276 | |
7277 /** | |
7278 * The new content of the file. | |
7279 */ | |
7280 String get content => _content; | |
7281 | |
7282 /** | |
7283 * The new content of the file. | |
7284 */ | |
7285 void set content(String value) { | |
7286 assert(value != null); | |
7287 this._content = value; | |
7288 } | |
7289 | |
7290 AddContentOverlay(String content) { | |
7291 this.content = content; | |
7292 } | |
7293 | |
7294 factory AddContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, O
bject json) { | |
7295 if (json == null) { | |
7296 json = {}; | |
7297 } | |
7298 if (json is Map) { | |
7299 if (json["type"] != "add") { | |
7300 throw jsonDecoder.mismatch(jsonPath, "equal " + "add", json); | |
7301 } | |
7302 String content; | |
7303 if (json.containsKey("content")) { | |
7304 content = jsonDecoder._decodeString(jsonPath + ".content", json["content
"]); | |
7305 } else { | |
7306 throw jsonDecoder.missingKey(jsonPath, "content"); | |
7307 } | |
7308 return new AddContentOverlay(content); | |
7309 } else { | |
7310 throw jsonDecoder.mismatch(jsonPath, "AddContentOverlay", json); | |
7311 } | |
7312 } | |
7313 | |
7314 Map<String, dynamic> toJson() { | |
7315 Map<String, dynamic> result = {}; | |
7316 result["type"] = "add"; | |
7317 result["content"] = content; | |
7318 return result; | |
7319 } | |
7320 | |
7321 @override | |
7322 String toString() => JSON.encode(toJson()); | |
7323 | |
7324 @override | |
7325 bool operator==(other) { | |
7326 if (other is AddContentOverlay) { | |
7327 return content == other.content; | |
7328 } | |
7329 return false; | |
7330 } | |
7331 | |
7332 @override | |
7333 int get hashCode { | |
7334 int hash = 0; | |
7335 hash = _JenkinsSmiHash.combine(hash, 704418402); | |
7336 hash = _JenkinsSmiHash.combine(hash, content.hashCode); | |
7337 return _JenkinsSmiHash.finish(hash); | |
7338 } | |
7339 } | |
7340 | |
7341 /** | |
7342 * AnalysisError | |
7343 * | |
7344 * { | |
7345 * "severity": AnalysisErrorSeverity | |
7346 * "type": AnalysisErrorType | |
7347 * "location": Location | |
7348 * "message": String | |
7349 * "correction": optional String | |
7350 * "hasFix": optional bool | |
7351 * } | |
7352 */ | |
7353 class AnalysisError implements HasToJson { | |
7354 AnalysisErrorSeverity _severity; | |
7355 | |
7356 AnalysisErrorType _type; | |
7357 | |
7358 Location _location; | |
7359 | |
7360 String _message; | |
7361 | |
7362 String _correction; | |
7363 | |
7364 bool _hasFix; | |
7365 | |
7366 /** | |
7367 * The severity of the error. | |
7368 */ | |
7369 AnalysisErrorSeverity get severity => _severity; | |
7370 | |
7371 /** | |
7372 * The severity of the error. | |
7373 */ | |
7374 void set severity(AnalysisErrorSeverity value) { | |
7375 assert(value != null); | |
7376 this._severity = value; | |
7377 } | |
7378 | |
7379 /** | |
7380 * The type of the error. | |
7381 */ | |
7382 AnalysisErrorType get type => _type; | |
7383 | |
7384 /** | |
7385 * The type of the error. | |
7386 */ | |
7387 void set type(AnalysisErrorType value) { | |
7388 assert(value != null); | |
7389 this._type = value; | |
7390 } | |
7391 | |
7392 /** | |
7393 * The location associated with the error. | |
7394 */ | |
7395 Location get location => _location; | |
7396 | |
7397 /** | |
7398 * The location associated with the error. | |
7399 */ | |
7400 void set location(Location value) { | |
7401 assert(value != null); | |
7402 this._location = value; | |
7403 } | |
7404 | |
7405 /** | |
7406 * The message to be displayed for this error. The message should indicate | |
7407 * what is wrong with the code and why it is wrong. | |
7408 */ | |
7409 String get message => _message; | |
7410 | |
7411 /** | |
7412 * The message to be displayed for this error. The message should indicate | |
7413 * what is wrong with the code and why it is wrong. | |
7414 */ | |
7415 void set message(String value) { | |
7416 assert(value != null); | |
7417 this._message = value; | |
7418 } | |
7419 | |
7420 /** | |
7421 * The correction message to be displayed for this error. The correction | |
7422 * message should indicate how the user can fix the error. The field is | |
7423 * omitted if there is no correction message associated with the error code. | |
7424 */ | |
7425 String get correction => _correction; | |
7426 | |
7427 /** | |
7428 * The correction message to be displayed for this error. The correction | |
7429 * message should indicate how the user can fix the error. The field is | |
7430 * omitted if there is no correction message associated with the error code. | |
7431 */ | |
7432 void set correction(String value) { | |
7433 this._correction = value; | |
7434 } | |
7435 | |
7436 /** | |
7437 * A hint to indicate to interested clients that this error has an associated | |
7438 * fix (or fixes). The absence of this field implies there are not known to | |
7439 * be fixes. Note that since the operation to calculate whether fixes apply | |
7440 * needs to be performant it is possible that complicated tests will be | |
7441 * skipped and a false negative returned. For this reason, this attribute | |
7442 * should be treated as a "hint". Despite the possibility of false negatives, | |
7443 * no false positives should be returned. If a client sees this flag set they | |
7444 * can proceed with the confidence that there are in fact associated fixes. | |
7445 */ | |
7446 bool get hasFix => _hasFix; | |
7447 | |
7448 /** | |
7449 * A hint to indicate to interested clients that this error has an associated | |
7450 * fix (or fixes). The absence of this field implies there are not known to | |
7451 * be fixes. Note that since the operation to calculate whether fixes apply | |
7452 * needs to be performant it is possible that complicated tests will be | |
7453 * skipped and a false negative returned. For this reason, this attribute | |
7454 * should be treated as a "hint". Despite the possibility of false negatives, | |
7455 * no false positives should be returned. If a client sees this flag set they | |
7456 * can proceed with the confidence that there are in fact associated fixes. | |
7457 */ | |
7458 void set hasFix(bool value) { | |
7459 this._hasFix = value; | |
7460 } | |
7461 | |
7462 AnalysisError(AnalysisErrorSeverity severity, AnalysisErrorType type, Location
location, String message, {String correction, bool hasFix}) { | |
7463 this.severity = severity; | |
7464 this.type = type; | |
7465 this.location = location; | |
7466 this.message = message; | |
7467 this.correction = correction; | |
7468 this.hasFix = hasFix; | |
7469 } | |
7470 | |
7471 factory AnalysisError.fromJson(JsonDecoder jsonDecoder, String jsonPath, Objec
t json) { | |
7472 if (json == null) { | |
7473 json = {}; | |
7474 } | |
7475 if (json is Map) { | |
7476 AnalysisErrorSeverity severity; | |
7477 if (json.containsKey("severity")) { | |
7478 severity = new AnalysisErrorSeverity.fromJson(jsonDecoder, jsonPath + ".
severity", json["severity"]); | |
7479 } else { | |
7480 throw jsonDecoder.missingKey(jsonPath, "severity"); | |
7481 } | |
7482 AnalysisErrorType type; | |
7483 if (json.containsKey("type")) { | |
7484 type = new AnalysisErrorType.fromJson(jsonDecoder, jsonPath + ".type", j
son["type"]); | |
7485 } else { | |
7486 throw jsonDecoder.missingKey(jsonPath, "type"); | |
7487 } | |
7488 Location location; | |
7489 if (json.containsKey("location")) { | |
7490 location = new Location.fromJson(jsonDecoder, jsonPath + ".location", js
on["location"]); | |
7491 } else { | |
7492 throw jsonDecoder.missingKey(jsonPath, "location"); | |
7493 } | |
7494 String message; | |
7495 if (json.containsKey("message")) { | |
7496 message = jsonDecoder._decodeString(jsonPath + ".message", json["message
"]); | |
7497 } else { | |
7498 throw jsonDecoder.missingKey(jsonPath, "message"); | |
7499 } | |
7500 String correction; | |
7501 if (json.containsKey("correction")) { | |
7502 correction = jsonDecoder._decodeString(jsonPath + ".correction", json["c
orrection"]); | |
7503 } | |
7504 bool hasFix; | |
7505 if (json.containsKey("hasFix")) { | |
7506 hasFix = jsonDecoder._decodeBool(jsonPath + ".hasFix", json["hasFix"]); | |
7507 } | |
7508 return new AnalysisError(severity, type, location, message, correction: co
rrection, hasFix: hasFix); | |
7509 } else { | |
7510 throw jsonDecoder.mismatch(jsonPath, "AnalysisError", json); | |
7511 } | |
7512 } | |
7513 | |
7514 Map<String, dynamic> toJson() { | |
7515 Map<String, dynamic> result = {}; | |
7516 result["severity"] = severity.toJson(); | |
7517 result["type"] = type.toJson(); | |
7518 result["location"] = location.toJson(); | |
7519 result["message"] = message; | |
7520 if (correction != null) { | |
7521 result["correction"] = correction; | |
7522 } | |
7523 if (hasFix != null) { | |
7524 result["hasFix"] = hasFix; | |
7525 } | |
7526 return result; | |
7527 } | |
7528 | |
7529 @override | |
7530 String toString() => JSON.encode(toJson()); | |
7531 | |
7532 @override | |
7533 bool operator==(other) { | |
7534 if (other is AnalysisError) { | |
7535 return severity == other.severity && | |
7536 type == other.type && | |
7537 location == other.location && | |
7538 message == other.message && | |
7539 correction == other.correction && | |
7540 hasFix == other.hasFix; | |
7541 } | |
7542 return false; | |
7543 } | |
7544 | |
7545 @override | |
7546 int get hashCode { | |
7547 int hash = 0; | |
7548 hash = _JenkinsSmiHash.combine(hash, severity.hashCode); | |
7549 hash = _JenkinsSmiHash.combine(hash, type.hashCode); | |
7550 hash = _JenkinsSmiHash.combine(hash, location.hashCode); | |
7551 hash = _JenkinsSmiHash.combine(hash, message.hashCode); | |
7552 hash = _JenkinsSmiHash.combine(hash, correction.hashCode); | |
7553 hash = _JenkinsSmiHash.combine(hash, hasFix.hashCode); | |
7554 return _JenkinsSmiHash.finish(hash); | |
7555 } | |
7556 } | |
7557 | |
7558 /** | |
7559 * AnalysisErrorFixes | |
7560 * | |
7561 * { | |
7562 * "error": AnalysisError | |
7563 * "fixes": List<SourceChange> | |
7564 * } | |
7565 */ | |
7566 class AnalysisErrorFixes implements HasToJson { | |
7567 AnalysisError _error; | |
7568 | |
7569 List<SourceChange> _fixes; | |
7570 | |
7571 /** | |
7572 * The error with which the fixes are associated. | |
7573 */ | |
7574 AnalysisError get error => _error; | |
7575 | |
7576 /** | |
7577 * The error with which the fixes are associated. | |
7578 */ | |
7579 void set error(AnalysisError value) { | |
7580 assert(value != null); | |
7581 this._error = value; | |
7582 } | |
7583 | |
7584 /** | |
7585 * The fixes associated with the error. | |
7586 */ | |
7587 List<SourceChange> get fixes => _fixes; | |
7588 | |
7589 /** | |
7590 * The fixes associated with the error. | |
7591 */ | |
7592 void set fixes(List<SourceChange> value) { | |
7593 assert(value != null); | |
7594 this._fixes = value; | |
7595 } | |
7596 | |
7597 AnalysisErrorFixes(AnalysisError error, {List<SourceChange> fixes}) { | |
7598 this.error = error; | |
7599 if (fixes == null) { | |
7600 this.fixes = <SourceChange>[]; | |
7601 } else { | |
7602 this.fixes = fixes; | |
7603 } | |
7604 } | |
7605 | |
7606 factory AnalysisErrorFixes.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json) { | |
7607 if (json == null) { | |
7608 json = {}; | |
7609 } | |
7610 if (json is Map) { | |
7611 AnalysisError error; | |
7612 if (json.containsKey("error")) { | |
7613 error = new AnalysisError.fromJson(jsonDecoder, jsonPath + ".error", jso
n["error"]); | |
7614 } else { | |
7615 throw jsonDecoder.missingKey(jsonPath, "error"); | |
7616 } | |
7617 List<SourceChange> fixes; | |
7618 if (json.containsKey("fixes")) { | |
7619 fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (Str
ing jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, j
son)); | |
7620 } else { | |
7621 throw jsonDecoder.missingKey(jsonPath, "fixes"); | |
7622 } | |
7623 return new AnalysisErrorFixes(error, fixes: fixes); | |
7624 } else { | |
7625 throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorFixes", json); | |
7626 } | |
7627 } | |
7628 | |
7629 Map<String, dynamic> toJson() { | |
7630 Map<String, dynamic> result = {}; | |
7631 result["error"] = error.toJson(); | |
7632 result["fixes"] = fixes.map((SourceChange value) => value.toJson()).toList()
; | |
7633 return result; | |
7634 } | |
7635 | |
7636 @override | |
7637 String toString() => JSON.encode(toJson()); | |
7638 | |
7639 @override | |
7640 bool operator==(other) { | |
7641 if (other is AnalysisErrorFixes) { | |
7642 return error == other.error && | |
7643 _listEqual(fixes, other.fixes, (SourceChange a, SourceChange b) => a =
= b); | |
7644 } | |
7645 return false; | |
7646 } | |
7647 | |
7648 @override | |
7649 int get hashCode { | |
7650 int hash = 0; | |
7651 hash = _JenkinsSmiHash.combine(hash, error.hashCode); | |
7652 hash = _JenkinsSmiHash.combine(hash, fixes.hashCode); | |
7653 return _JenkinsSmiHash.finish(hash); | |
7654 } | |
7655 } | |
7656 | |
7657 /** | |
7658 * AnalysisErrorSeverity | |
7659 * | |
7660 * enum { | |
7661 * INFO | |
7662 * WARNING | |
7663 * ERROR | |
7664 * } | |
7665 */ | |
7666 class AnalysisErrorSeverity implements Enum { | |
7667 static const INFO = const AnalysisErrorSeverity._("INFO"); | |
7668 | |
7669 static const WARNING = const AnalysisErrorSeverity._("WARNING"); | |
7670 | |
7671 static const ERROR = const AnalysisErrorSeverity._("ERROR"); | |
7672 | |
7673 /** | |
7674 * A list containing all of the enum values that are defined. | |
7675 */ | |
7676 static const List<AnalysisErrorSeverity> VALUES = const <AnalysisErrorSeverity
>[INFO, WARNING, ERROR]; | |
7677 | |
7678 final String name; | |
7679 | |
7680 const AnalysisErrorSeverity._(this.name); | |
7681 | |
7682 factory AnalysisErrorSeverity(String name) { | |
7683 switch (name) { | |
7684 case "INFO": | |
7685 return INFO; | |
7686 case "WARNING": | |
7687 return WARNING; | |
7688 case "ERROR": | |
7689 return ERROR; | |
7690 } | |
7691 throw new Exception('Illegal enum value: $name'); | |
7692 } | |
7693 | |
7694 factory AnalysisErrorSeverity.fromJson(JsonDecoder jsonDecoder, String jsonPat
h, Object json) { | |
7695 if (json is String) { | |
7696 try { | |
7697 return new AnalysisErrorSeverity(json); | |
7698 } catch(_) { | |
7699 // Fall through | |
7700 } | |
7701 } | |
7702 throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorSeverity", json); | |
7703 } | |
7704 | |
7705 @override | |
7706 String toString() => "AnalysisErrorSeverity.$name"; | |
7707 | |
7708 String toJson() => name; | |
7709 } | |
7710 | |
7711 /** | |
7712 * AnalysisErrorType | |
7713 * | |
7714 * enum { | |
7715 * CHECKED_MODE_COMPILE_TIME_ERROR | |
7716 * COMPILE_TIME_ERROR | |
7717 * HINT | |
7718 * LINT | |
7719 * STATIC_TYPE_WARNING | |
7720 * STATIC_WARNING | |
7721 * SYNTACTIC_ERROR | |
7722 * TODO | |
7723 * } | |
7724 */ | |
7725 class AnalysisErrorType implements Enum { | |
7726 static const CHECKED_MODE_COMPILE_TIME_ERROR = const AnalysisErrorType._("CHEC
KED_MODE_COMPILE_TIME_ERROR"); | |
7727 | |
7728 static const COMPILE_TIME_ERROR = const AnalysisErrorType._("COMPILE_TIME_ERRO
R"); | |
7729 | |
7730 static const HINT = const AnalysisErrorType._("HINT"); | |
7731 | |
7732 static const LINT = const AnalysisErrorType._("LINT"); | |
7733 | |
7734 static const STATIC_TYPE_WARNING = const AnalysisErrorType._("STATIC_TYPE_WARN
ING"); | |
7735 | |
7736 static const STATIC_WARNING = const AnalysisErrorType._("STATIC_WARNING"); | |
7737 | |
7738 static const SYNTACTIC_ERROR = const AnalysisErrorType._("SYNTACTIC_ERROR"); | |
7739 | |
7740 static const TODO = const AnalysisErrorType._("TODO"); | |
7741 | |
7742 /** | |
7743 * A list containing all of the enum values that are defined. | |
7744 */ | |
7745 static const List<AnalysisErrorType> VALUES = const <AnalysisErrorType>[CHECKE
D_MODE_COMPILE_TIME_ERROR, COMPILE_TIME_ERROR, HINT, LINT, STATIC_TYPE_WARNING,
STATIC_WARNING, SYNTACTIC_ERROR, TODO]; | |
7746 | |
7747 final String name; | |
7748 | |
7749 const AnalysisErrorType._(this.name); | |
7750 | |
7751 factory AnalysisErrorType(String name) { | |
7752 switch (name) { | |
7753 case "CHECKED_MODE_COMPILE_TIME_ERROR": | |
7754 return CHECKED_MODE_COMPILE_TIME_ERROR; | |
7755 case "COMPILE_TIME_ERROR": | |
7756 return COMPILE_TIME_ERROR; | |
7757 case "HINT": | |
7758 return HINT; | |
7759 case "LINT": | |
7760 return LINT; | |
7761 case "STATIC_TYPE_WARNING": | |
7762 return STATIC_TYPE_WARNING; | |
7763 case "STATIC_WARNING": | |
7764 return STATIC_WARNING; | |
7765 case "SYNTACTIC_ERROR": | |
7766 return SYNTACTIC_ERROR; | |
7767 case "TODO": | |
7768 return TODO; | |
7769 } | |
7770 throw new Exception('Illegal enum value: $name'); | |
7771 } | |
7772 | |
7773 factory AnalysisErrorType.fromJson(JsonDecoder jsonDecoder, String jsonPath, O
bject json) { | |
7774 if (json is String) { | |
7775 try { | |
7776 return new AnalysisErrorType(json); | |
7777 } catch(_) { | |
7778 // Fall through | |
7779 } | |
7780 } | |
7781 throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorType", json); | |
7782 } | |
7783 | |
7784 @override | |
7785 String toString() => "AnalysisErrorType.$name"; | |
7786 | |
7787 String toJson() => name; | |
7788 } | |
7789 | |
7790 /** | |
7791 * AnalysisOptions | |
7792 * | |
7793 * { | |
7794 * "enableAsync": optional bool | |
7795 * "enableDeferredLoading": optional bool | |
7796 * "enableEnums": optional bool | |
7797 * "enableNullAwareOperators": optional bool | |
7798 * "enableSuperMixins": optional bool | |
7799 * "generateDart2jsHints": optional bool | |
7800 * "generateHints": optional bool | |
7801 * "generateLints": optional bool | |
7802 * } | |
7803 */ | |
7804 class AnalysisOptions implements HasToJson { | |
7805 bool _enableAsync; | |
7806 | |
7807 bool _enableDeferredLoading; | |
7808 | |
7809 bool _enableEnums; | |
7810 | |
7811 bool _enableNullAwareOperators; | |
7812 | |
7813 bool _enableSuperMixins; | |
7814 | |
7815 bool _generateDart2jsHints; | |
7816 | |
7817 bool _generateHints; | |
7818 | |
7819 bool _generateLints; | |
7820 | |
7821 /** | |
7822 * Deprecated: this feature is always enabled. | |
7823 * | |
7824 * True if the client wants to enable support for the proposed async feature. | |
7825 */ | |
7826 bool get enableAsync => _enableAsync; | |
7827 | |
7828 /** | |
7829 * Deprecated: this feature is always enabled. | |
7830 * | |
7831 * True if the client wants to enable support for the proposed async feature. | |
7832 */ | |
7833 void set enableAsync(bool value) { | |
7834 this._enableAsync = value; | |
7835 } | |
7836 | |
7837 /** | |
7838 * Deprecated: this feature is always enabled. | |
7839 * | |
7840 * True if the client wants to enable support for the proposed deferred | |
7841 * loading feature. | |
7842 */ | |
7843 bool get enableDeferredLoading => _enableDeferredLoading; | |
7844 | |
7845 /** | |
7846 * Deprecated: this feature is always enabled. | |
7847 * | |
7848 * True if the client wants to enable support for the proposed deferred | |
7849 * loading feature. | |
7850 */ | |
7851 void set enableDeferredLoading(bool value) { | |
7852 this._enableDeferredLoading = value; | |
7853 } | |
7854 | |
7855 /** | |
7856 * Deprecated: this feature is always enabled. | |
7857 * | |
7858 * True if the client wants to enable support for the proposed enum feature. | |
7859 */ | |
7860 bool get enableEnums => _enableEnums; | |
7861 | |
7862 /** | |
7863 * Deprecated: this feature is always enabled. | |
7864 * | |
7865 * True if the client wants to enable support for the proposed enum feature. | |
7866 */ | |
7867 void set enableEnums(bool value) { | |
7868 this._enableEnums = value; | |
7869 } | |
7870 | |
7871 /** | |
7872 * Deprecated: this feature is always enabled. | |
7873 * | |
7874 * True if the client wants to enable support for the proposed "null aware | |
7875 * operators" feature. | |
7876 */ | |
7877 bool get enableNullAwareOperators => _enableNullAwareOperators; | |
7878 | |
7879 /** | |
7880 * Deprecated: this feature is always enabled. | |
7881 * | |
7882 * True if the client wants to enable support for the proposed "null aware | |
7883 * operators" feature. | |
7884 */ | |
7885 void set enableNullAwareOperators(bool value) { | |
7886 this._enableNullAwareOperators = value; | |
7887 } | |
7888 | |
7889 /** | |
7890 * True if the client wants to enable spport for the proposed "less | |
7891 * restricted mixins" proposal (DEP 34). | |
7892 */ | |
7893 bool get enableSuperMixins => _enableSuperMixins; | |
7894 | |
7895 /** | |
7896 * True if the client wants to enable spport for the proposed "less | |
7897 * restricted mixins" proposal (DEP 34). | |
7898 */ | |
7899 void set enableSuperMixins(bool value) { | |
7900 this._enableSuperMixins = value; | |
7901 } | |
7902 | |
7903 /** | |
7904 * True if hints that are specific to dart2js should be generated. This | |
7905 * option is ignored if generateHints is false. | |
7906 */ | |
7907 bool get generateDart2jsHints => _generateDart2jsHints; | |
7908 | |
7909 /** | |
7910 * True if hints that are specific to dart2js should be generated. This | |
7911 * option is ignored if generateHints is false. | |
7912 */ | |
7913 void set generateDart2jsHints(bool value) { | |
7914 this._generateDart2jsHints = value; | |
7915 } | |
7916 | |
7917 /** | |
7918 * True if hints should be generated as part of generating errors and | |
7919 * warnings. | |
7920 */ | |
7921 bool get generateHints => _generateHints; | |
7922 | |
7923 /** | |
7924 * True if hints should be generated as part of generating errors and | |
7925 * warnings. | |
7926 */ | |
7927 void set generateHints(bool value) { | |
7928 this._generateHints = value; | |
7929 } | |
7930 | |
7931 /** | |
7932 * True if lints should be generated as part of generating errors and | |
7933 * warnings. | |
7934 */ | |
7935 bool get generateLints => _generateLints; | |
7936 | |
7937 /** | |
7938 * True if lints should be generated as part of generating errors and | |
7939 * warnings. | |
7940 */ | |
7941 void set generateLints(bool value) { | |
7942 this._generateLints = value; | |
7943 } | |
7944 | |
7945 AnalysisOptions({bool enableAsync, bool enableDeferredLoading, bool enableEnum
s, bool enableNullAwareOperators, bool enableSuperMixins, bool generateDart2jsHi
nts, bool generateHints, bool generateLints}) { | |
7946 this.enableAsync = enableAsync; | |
7947 this.enableDeferredLoading = enableDeferredLoading; | |
7948 this.enableEnums = enableEnums; | |
7949 this.enableNullAwareOperators = enableNullAwareOperators; | |
7950 this.enableSuperMixins = enableSuperMixins; | |
7951 this.generateDart2jsHints = generateDart2jsHints; | |
7952 this.generateHints = generateHints; | |
7953 this.generateLints = generateLints; | |
7954 } | |
7955 | |
7956 factory AnalysisOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obj
ect json) { | |
7957 if (json == null) { | |
7958 json = {}; | |
7959 } | |
7960 if (json is Map) { | |
7961 bool enableAsync; | |
7962 if (json.containsKey("enableAsync")) { | |
7963 enableAsync = jsonDecoder._decodeBool(jsonPath + ".enableAsync", json["e
nableAsync"]); | |
7964 } | |
7965 bool enableDeferredLoading; | |
7966 if (json.containsKey("enableDeferredLoading")) { | |
7967 enableDeferredLoading = jsonDecoder._decodeBool(jsonPath + ".enableDefer
redLoading", json["enableDeferredLoading"]); | |
7968 } | |
7969 bool enableEnums; | |
7970 if (json.containsKey("enableEnums")) { | |
7971 enableEnums = jsonDecoder._decodeBool(jsonPath + ".enableEnums", json["e
nableEnums"]); | |
7972 } | |
7973 bool enableNullAwareOperators; | |
7974 if (json.containsKey("enableNullAwareOperators")) { | |
7975 enableNullAwareOperators = jsonDecoder._decodeBool(jsonPath + ".enableNu
llAwareOperators", json["enableNullAwareOperators"]); | |
7976 } | |
7977 bool enableSuperMixins; | |
7978 if (json.containsKey("enableSuperMixins")) { | |
7979 enableSuperMixins = jsonDecoder._decodeBool(jsonPath + ".enableSuperMixi
ns", json["enableSuperMixins"]); | |
7980 } | |
7981 bool generateDart2jsHints; | |
7982 if (json.containsKey("generateDart2jsHints")) { | |
7983 generateDart2jsHints = jsonDecoder._decodeBool(jsonPath + ".generateDart
2jsHints", json["generateDart2jsHints"]); | |
7984 } | |
7985 bool generateHints; | |
7986 if (json.containsKey("generateHints")) { | |
7987 generateHints = jsonDecoder._decodeBool(jsonPath + ".generateHints", jso
n["generateHints"]); | |
7988 } | |
7989 bool generateLints; | |
7990 if (json.containsKey("generateLints")) { | |
7991 generateLints = jsonDecoder._decodeBool(jsonPath + ".generateLints", jso
n["generateLints"]); | |
7992 } | |
7993 return new AnalysisOptions(enableAsync: enableAsync, enableDeferredLoading
: enableDeferredLoading, enableEnums: enableEnums, enableNullAwareOperators: ena
bleNullAwareOperators, enableSuperMixins: enableSuperMixins, generateDart2jsHint
s: generateDart2jsHints, generateHints: generateHints, generateLints: generateLi
nts); | |
7994 } else { | |
7995 throw jsonDecoder.mismatch(jsonPath, "AnalysisOptions", json); | |
7996 } | |
7997 } | |
7998 | |
7999 Map<String, dynamic> toJson() { | |
8000 Map<String, dynamic> result = {}; | |
8001 if (enableAsync != null) { | |
8002 result["enableAsync"] = enableAsync; | |
8003 } | |
8004 if (enableDeferredLoading != null) { | |
8005 result["enableDeferredLoading"] = enableDeferredLoading; | |
8006 } | |
8007 if (enableEnums != null) { | |
8008 result["enableEnums"] = enableEnums; | |
8009 } | |
8010 if (enableNullAwareOperators != null) { | |
8011 result["enableNullAwareOperators"] = enableNullAwareOperators; | |
8012 } | |
8013 if (enableSuperMixins != null) { | |
8014 result["enableSuperMixins"] = enableSuperMixins; | |
8015 } | |
8016 if (generateDart2jsHints != null) { | |
8017 result["generateDart2jsHints"] = generateDart2jsHints; | |
8018 } | |
8019 if (generateHints != null) { | |
8020 result["generateHints"] = generateHints; | |
8021 } | |
8022 if (generateLints != null) { | |
8023 result["generateLints"] = generateLints; | |
8024 } | |
8025 return result; | |
8026 } | |
8027 | |
8028 @override | |
8029 String toString() => JSON.encode(toJson()); | |
8030 | |
8031 @override | |
8032 bool operator==(other) { | |
8033 if (other is AnalysisOptions) { | |
8034 return enableAsync == other.enableAsync && | |
8035 enableDeferredLoading == other.enableDeferredLoading && | |
8036 enableEnums == other.enableEnums && | |
8037 enableNullAwareOperators == other.enableNullAwareOperators && | |
8038 enableSuperMixins == other.enableSuperMixins && | |
8039 generateDart2jsHints == other.generateDart2jsHints && | |
8040 generateHints == other.generateHints && | |
8041 generateLints == other.generateLints; | |
8042 } | |
8043 return false; | |
8044 } | |
8045 | |
8046 @override | |
8047 int get hashCode { | |
8048 int hash = 0; | |
8049 hash = _JenkinsSmiHash.combine(hash, enableAsync.hashCode); | |
8050 hash = _JenkinsSmiHash.combine(hash, enableDeferredLoading.hashCode); | |
8051 hash = _JenkinsSmiHash.combine(hash, enableEnums.hashCode); | |
8052 hash = _JenkinsSmiHash.combine(hash, enableNullAwareOperators.hashCode); | |
8053 hash = _JenkinsSmiHash.combine(hash, enableSuperMixins.hashCode); | |
8054 hash = _JenkinsSmiHash.combine(hash, generateDart2jsHints.hashCode); | |
8055 hash = _JenkinsSmiHash.combine(hash, generateHints.hashCode); | |
8056 hash = _JenkinsSmiHash.combine(hash, generateLints.hashCode); | |
8057 return _JenkinsSmiHash.finish(hash); | |
8058 } | |
8059 } | |
8060 | |
8061 /** | |
8062 * AnalysisService | |
8063 * | |
8064 * enum { | |
8065 * FOLDING | |
8066 * HIGHLIGHTS | |
8067 * IMPLEMENTED | |
8068 * INVALIDATE | |
8069 * NAVIGATION | |
8070 * OCCURRENCES | |
8071 * OUTLINE | |
8072 * OVERRIDES | |
8073 * } | |
8074 */ | |
8075 class AnalysisService implements Enum { | |
8076 static const FOLDING = const AnalysisService._("FOLDING"); | |
8077 | |
8078 static const HIGHLIGHTS = const AnalysisService._("HIGHLIGHTS"); | |
8079 | |
8080 static const IMPLEMENTED = const AnalysisService._("IMPLEMENTED"); | |
8081 | |
8082 /** | |
8083 * This service is not currently implemented and will become a | |
8084 * GeneralAnalysisService in a future release. | |
8085 */ | |
8086 static const INVALIDATE = const AnalysisService._("INVALIDATE"); | |
8087 | |
8088 static const NAVIGATION = const AnalysisService._("NAVIGATION"); | |
8089 | |
8090 static const OCCURRENCES = const AnalysisService._("OCCURRENCES"); | |
8091 | |
8092 static const OUTLINE = const AnalysisService._("OUTLINE"); | |
8093 | |
8094 static const OVERRIDES = const AnalysisService._("OVERRIDES"); | |
8095 | |
8096 /** | |
8097 * A list containing all of the enum values that are defined. | |
8098 */ | |
8099 static const List<AnalysisService> VALUES = const <AnalysisService>[FOLDING, H
IGHLIGHTS, IMPLEMENTED, INVALIDATE, NAVIGATION, OCCURRENCES, OUTLINE, OVERRIDES]
; | |
8100 | |
8101 final String name; | |
8102 | |
8103 const AnalysisService._(this.name); | |
8104 | |
8105 factory AnalysisService(String name) { | |
8106 switch (name) { | |
8107 case "FOLDING": | |
8108 return FOLDING; | |
8109 case "HIGHLIGHTS": | |
8110 return HIGHLIGHTS; | |
8111 case "IMPLEMENTED": | |
8112 return IMPLEMENTED; | |
8113 case "INVALIDATE": | |
8114 return INVALIDATE; | |
8115 case "NAVIGATION": | |
8116 return NAVIGATION; | |
8117 case "OCCURRENCES": | |
8118 return OCCURRENCES; | |
8119 case "OUTLINE": | |
8120 return OUTLINE; | |
8121 case "OVERRIDES": | |
8122 return OVERRIDES; | |
8123 } | |
8124 throw new Exception('Illegal enum value: $name'); | |
8125 } | |
8126 | |
8127 factory AnalysisService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obj
ect json) { | |
8128 if (json is String) { | |
8129 try { | |
8130 return new AnalysisService(json); | |
8131 } catch(_) { | |
8132 // Fall through | |
8133 } | |
8134 } | |
8135 throw jsonDecoder.mismatch(jsonPath, "AnalysisService", json); | |
8136 } | |
8137 | |
8138 @override | |
8139 String toString() => "AnalysisService.$name"; | |
8140 | |
8141 String toJson() => name; | |
8142 } | |
8143 | |
8144 /** | |
8145 * AnalysisStatus | |
8146 * | |
8147 * { | |
8148 * "isAnalyzing": bool | |
8149 * "analysisTarget": optional String | |
8150 * } | |
8151 */ | |
8152 class AnalysisStatus implements HasToJson { | |
8153 bool _isAnalyzing; | |
8154 | |
8155 String _analysisTarget; | |
8156 | |
8157 /** | |
8158 * True if analysis is currently being performed. | |
8159 */ | |
8160 bool get isAnalyzing => _isAnalyzing; | |
8161 | |
8162 /** | |
8163 * True if analysis is currently being performed. | |
8164 */ | |
8165 void set isAnalyzing(bool value) { | |
8166 assert(value != null); | |
8167 this._isAnalyzing = value; | |
8168 } | |
8169 | |
8170 /** | |
8171 * The name of the current target of analysis. This field is omitted if | |
8172 * analyzing is false. | |
8173 */ | |
8174 String get analysisTarget => _analysisTarget; | |
8175 | |
8176 /** | |
8177 * The name of the current target of analysis. This field is omitted if | |
8178 * analyzing is false. | |
8179 */ | |
8180 void set analysisTarget(String value) { | |
8181 this._analysisTarget = value; | |
8182 } | |
8183 | |
8184 AnalysisStatus(bool isAnalyzing, {String analysisTarget}) { | |
8185 this.isAnalyzing = isAnalyzing; | |
8186 this.analysisTarget = analysisTarget; | |
8187 } | |
8188 | |
8189 factory AnalysisStatus.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obje
ct json) { | |
8190 if (json == null) { | |
8191 json = {}; | |
8192 } | |
8193 if (json is Map) { | |
8194 bool isAnalyzing; | |
8195 if (json.containsKey("isAnalyzing")) { | |
8196 isAnalyzing = jsonDecoder._decodeBool(jsonPath + ".isAnalyzing", json["i
sAnalyzing"]); | |
8197 } else { | |
8198 throw jsonDecoder.missingKey(jsonPath, "isAnalyzing"); | |
8199 } | |
8200 String analysisTarget; | |
8201 if (json.containsKey("analysisTarget")) { | |
8202 analysisTarget = jsonDecoder._decodeString(jsonPath + ".analysisTarget",
json["analysisTarget"]); | |
8203 } | |
8204 return new AnalysisStatus(isAnalyzing, analysisTarget: analysisTarget); | |
8205 } else { | |
8206 throw jsonDecoder.mismatch(jsonPath, "AnalysisStatus", json); | |
8207 } | |
8208 } | |
8209 | |
8210 Map<String, dynamic> toJson() { | |
8211 Map<String, dynamic> result = {}; | |
8212 result["isAnalyzing"] = isAnalyzing; | |
8213 if (analysisTarget != null) { | |
8214 result["analysisTarget"] = analysisTarget; | |
8215 } | |
8216 return result; | |
8217 } | |
8218 | |
8219 @override | |
8220 String toString() => JSON.encode(toJson()); | |
8221 | |
8222 @override | |
8223 bool operator==(other) { | |
8224 if (other is AnalysisStatus) { | |
8225 return isAnalyzing == other.isAnalyzing && | |
8226 analysisTarget == other.analysisTarget; | |
8227 } | |
8228 return false; | |
8229 } | |
8230 | |
8231 @override | |
8232 int get hashCode { | |
8233 int hash = 0; | |
8234 hash = _JenkinsSmiHash.combine(hash, isAnalyzing.hashCode); | |
8235 hash = _JenkinsSmiHash.combine(hash, analysisTarget.hashCode); | |
8236 return _JenkinsSmiHash.finish(hash); | |
8237 } | |
8238 } | |
8239 | |
8240 /** | |
8241 * ChangeContentOverlay | |
8242 * | |
8243 * { | |
8244 * "type": "change" | |
8245 * "edits": List<SourceEdit> | |
8246 * } | |
8247 */ | |
8248 class ChangeContentOverlay implements HasToJson { | |
8249 List<SourceEdit> _edits; | |
8250 | |
8251 /** | |
8252 * The edits to be applied to the file. | |
8253 */ | |
8254 List<SourceEdit> get edits => _edits; | |
8255 | |
8256 /** | |
8257 * The edits to be applied to the file. | |
8258 */ | |
8259 void set edits(List<SourceEdit> value) { | |
8260 assert(value != null); | |
8261 this._edits = value; | |
8262 } | |
8263 | |
8264 ChangeContentOverlay(List<SourceEdit> edits) { | |
8265 this.edits = edits; | |
8266 } | |
8267 | |
8268 factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath
, Object json) { | |
8269 if (json == null) { | |
8270 json = {}; | |
8271 } | |
8272 if (json is Map) { | |
8273 if (json["type"] != "change") { | |
8274 throw jsonDecoder.mismatch(jsonPath, "equal " + "change", json); | |
8275 } | |
8276 List<SourceEdit> edits; | |
8277 if (json.containsKey("edits")) { | |
8278 edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (Str
ing jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, jso
n)); | |
8279 } else { | |
8280 throw jsonDecoder.missingKey(jsonPath, "edits"); | |
8281 } | |
8282 return new ChangeContentOverlay(edits); | |
8283 } else { | |
8284 throw jsonDecoder.mismatch(jsonPath, "ChangeContentOverlay", json); | |
8285 } | |
8286 } | |
8287 | |
8288 Map<String, dynamic> toJson() { | |
8289 Map<String, dynamic> result = {}; | |
8290 result["type"] = "change"; | |
8291 result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList(); | |
8292 return result; | |
8293 } | |
8294 | |
8295 @override | |
8296 String toString() => JSON.encode(toJson()); | |
8297 | |
8298 @override | |
8299 bool operator==(other) { | |
8300 if (other is ChangeContentOverlay) { | |
8301 return _listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a ==
b); | |
8302 } | |
8303 return false; | |
8304 } | |
8305 | |
8306 @override | |
8307 int get hashCode { | |
8308 int hash = 0; | |
8309 hash = _JenkinsSmiHash.combine(hash, 873118866); | |
8310 hash = _JenkinsSmiHash.combine(hash, edits.hashCode); | |
8311 return _JenkinsSmiHash.finish(hash); | |
8312 } | |
8313 } | |
8314 | |
8315 /** | |
8316 * CompletionSuggestion | |
8317 * | |
8318 * { | |
8319 * "kind": CompletionSuggestionKind | |
8320 * "relevance": int | |
8321 * "completion": String | |
8322 * "selectionOffset": int | |
8323 * "selectionLength": int | |
8324 * "isDeprecated": bool | |
8325 * "isPotential": bool | |
8326 * "docSummary": optional String | |
8327 * "docComplete": optional String | |
8328 * "declaringType": optional String | |
8329 * "element": optional Element | |
8330 * "returnType": optional String | |
8331 * "parameterNames": optional List<String> | |
8332 * "parameterTypes": optional List<String> | |
8333 * "requiredParameterCount": optional int | |
8334 * "hasNamedParameters": optional bool | |
8335 * "parameterName": optional String | |
8336 * "parameterType": optional String | |
8337 * "importUri": optional String | |
8338 * } | |
8339 */ | |
8340 class CompletionSuggestion implements HasToJson { | |
8341 CompletionSuggestionKind _kind; | |
8342 | |
8343 int _relevance; | |
8344 | |
8345 String _completion; | |
8346 | |
8347 int _selectionOffset; | |
8348 | |
8349 int _selectionLength; | |
8350 | |
8351 bool _isDeprecated; | |
8352 | |
8353 bool _isPotential; | |
8354 | |
8355 String _docSummary; | |
8356 | |
8357 String _docComplete; | |
8358 | |
8359 String _declaringType; | |
8360 | |
8361 Element _element; | |
8362 | |
8363 String _returnType; | |
8364 | |
8365 List<String> _parameterNames; | |
8366 | |
8367 List<String> _parameterTypes; | |
8368 | |
8369 int _requiredParameterCount; | |
8370 | |
8371 bool _hasNamedParameters; | |
8372 | |
8373 String _parameterName; | |
8374 | |
8375 String _parameterType; | |
8376 | |
8377 String _importUri; | |
8378 | |
8379 /** | |
8380 * The kind of element being suggested. | |
8381 */ | |
8382 CompletionSuggestionKind get kind => _kind; | |
8383 | |
8384 /** | |
8385 * The kind of element being suggested. | |
8386 */ | |
8387 void set kind(CompletionSuggestionKind value) { | |
8388 assert(value != null); | |
8389 this._kind = value; | |
8390 } | |
8391 | |
8392 /** | |
8393 * The relevance of this completion suggestion where a higher number | |
8394 * indicates a higher relevance. | |
8395 */ | |
8396 int get relevance => _relevance; | |
8397 | |
8398 /** | |
8399 * The relevance of this completion suggestion where a higher number | |
8400 * indicates a higher relevance. | |
8401 */ | |
8402 void set relevance(int value) { | |
8403 assert(value != null); | |
8404 this._relevance = value; | |
8405 } | |
8406 | |
8407 /** | |
8408 * The identifier to be inserted if the suggestion is selected. If the | |
8409 * suggestion is for a method or function, the client might want to | |
8410 * additionally insert a template for the parameters. The information | |
8411 * required in order to do so is contained in other fields. | |
8412 */ | |
8413 String get completion => _completion; | |
8414 | |
8415 /** | |
8416 * The identifier to be inserted if the suggestion is selected. If the | |
8417 * suggestion is for a method or function, the client might want to | |
8418 * additionally insert a template for the parameters. The information | |
8419 * required in order to do so is contained in other fields. | |
8420 */ | |
8421 void set completion(String value) { | |
8422 assert(value != null); | |
8423 this._completion = value; | |
8424 } | |
8425 | |
8426 /** | |
8427 * The offset, relative to the beginning of the completion, of where the | |
8428 * selection should be placed after insertion. | |
8429 */ | |
8430 int get selectionOffset => _selectionOffset; | |
8431 | |
8432 /** | |
8433 * The offset, relative to the beginning of the completion, of where the | |
8434 * selection should be placed after insertion. | |
8435 */ | |
8436 void set selectionOffset(int value) { | |
8437 assert(value != null); | |
8438 this._selectionOffset = value; | |
8439 } | |
8440 | |
8441 /** | |
8442 * The number of characters that should be selected after insertion. | |
8443 */ | |
8444 int get selectionLength => _selectionLength; | |
8445 | |
8446 /** | |
8447 * The number of characters that should be selected after insertion. | |
8448 */ | |
8449 void set selectionLength(int value) { | |
8450 assert(value != null); | |
8451 this._selectionLength = value; | |
8452 } | |
8453 | |
8454 /** | |
8455 * True if the suggested element is deprecated. | |
8456 */ | |
8457 bool get isDeprecated => _isDeprecated; | |
8458 | |
8459 /** | |
8460 * True if the suggested element is deprecated. | |
8461 */ | |
8462 void set isDeprecated(bool value) { | |
8463 assert(value != null); | |
8464 this._isDeprecated = value; | |
8465 } | |
8466 | |
8467 /** | |
8468 * True if the element is not known to be valid for the target. This happens | |
8469 * if the type of the target is dynamic. | |
8470 */ | |
8471 bool get isPotential => _isPotential; | |
8472 | |
8473 /** | |
8474 * True if the element is not known to be valid for the target. This happens | |
8475 * if the type of the target is dynamic. | |
8476 */ | |
8477 void set isPotential(bool value) { | |
8478 assert(value != null); | |
8479 this._isPotential = value; | |
8480 } | |
8481 | |
8482 /** | |
8483 * An abbreviated version of the Dartdoc associated with the element being | |
8484 * suggested, This field is omitted if there is no Dartdoc associated with | |
8485 * the element. | |
8486 */ | |
8487 String get docSummary => _docSummary; | |
8488 | |
8489 /** | |
8490 * An abbreviated version of the Dartdoc associated with the element being | |
8491 * suggested, This field is omitted if there is no Dartdoc associated with | |
8492 * the element. | |
8493 */ | |
8494 void set docSummary(String value) { | |
8495 this._docSummary = value; | |
8496 } | |
8497 | |
8498 /** | |
8499 * The Dartdoc associated with the element being suggested, This field is | |
8500 * omitted if there is no Dartdoc associated with the element. | |
8501 */ | |
8502 String get docComplete => _docComplete; | |
8503 | |
8504 /** | |
8505 * The Dartdoc associated with the element being suggested, This field is | |
8506 * omitted if there is no Dartdoc associated with the element. | |
8507 */ | |
8508 void set docComplete(String value) { | |
8509 this._docComplete = value; | |
8510 } | |
8511 | |
8512 /** | |
8513 * The class that declares the element being suggested. This field is omitted | |
8514 * if the suggested element is not a member of a class. | |
8515 */ | |
8516 String get declaringType => _declaringType; | |
8517 | |
8518 /** | |
8519 * The class that declares the element being suggested. This field is omitted | |
8520 * if the suggested element is not a member of a class. | |
8521 */ | |
8522 void set declaringType(String value) { | |
8523 this._declaringType = value; | |
8524 } | |
8525 | |
8526 /** | |
8527 * Information about the element reference being suggested. | |
8528 */ | |
8529 Element get element => _element; | |
8530 | |
8531 /** | |
8532 * Information about the element reference being suggested. | |
8533 */ | |
8534 void set element(Element value) { | |
8535 this._element = value; | |
8536 } | |
8537 | |
8538 /** | |
8539 * The return type of the getter, function or method or the type of the field | |
8540 * being suggested. This field is omitted if the suggested element is not a | |
8541 * getter, function or method. | |
8542 */ | |
8543 String get returnType => _returnType; | |
8544 | |
8545 /** | |
8546 * The return type of the getter, function or method or the type of the field | |
8547 * being suggested. This field is omitted if the suggested element is not a | |
8548 * getter, function or method. | |
8549 */ | |
8550 void set returnType(String value) { | |
8551 this._returnType = value; | |
8552 } | |
8553 | |
8554 /** | |
8555 * The names of the parameters of the function or method being suggested. | |
8556 * This field is omitted if the suggested element is not a setter, function | |
8557 * or method. | |
8558 */ | |
8559 List<String> get parameterNames => _parameterNames; | |
8560 | |
8561 /** | |
8562 * The names of the parameters of the function or method being suggested. | |
8563 * This field is omitted if the suggested element is not a setter, function | |
8564 * or method. | |
8565 */ | |
8566 void set parameterNames(List<String> value) { | |
8567 this._parameterNames = value; | |
8568 } | |
8569 | |
8570 /** | |
8571 * The types of the parameters of the function or method being suggested. | |
8572 * This field is omitted if the parameterNames field is omitted. | |
8573 */ | |
8574 List<String> get parameterTypes => _parameterTypes; | |
8575 | |
8576 /** | |
8577 * The types of the parameters of the function or method being suggested. | |
8578 * This field is omitted if the parameterNames field is omitted. | |
8579 */ | |
8580 void set parameterTypes(List<String> value) { | |
8581 this._parameterTypes = value; | |
8582 } | |
8583 | |
8584 /** | |
8585 * The number of required parameters for the function or method being | |
8586 * suggested. This field is omitted if the parameterNames field is omitted. | |
8587 */ | |
8588 int get requiredParameterCount => _requiredParameterCount; | |
8589 | |
8590 /** | |
8591 * The number of required parameters for the function or method being | |
8592 * suggested. This field is omitted if the parameterNames field is omitted. | |
8593 */ | |
8594 void set requiredParameterCount(int value) { | |
8595 this._requiredParameterCount = value; | |
8596 } | |
8597 | |
8598 /** | |
8599 * True if the function or method being suggested has at least one named | |
8600 * parameter. This field is omitted if the parameterNames field is omitted. | |
8601 */ | |
8602 bool get hasNamedParameters => _hasNamedParameters; | |
8603 | |
8604 /** | |
8605 * True if the function or method being suggested has at least one named | |
8606 * parameter. This field is omitted if the parameterNames field is omitted. | |
8607 */ | |
8608 void set hasNamedParameters(bool value) { | |
8609 this._hasNamedParameters = value; | |
8610 } | |
8611 | |
8612 /** | |
8613 * The name of the optional parameter being suggested. This field is omitted | |
8614 * if the suggestion is not the addition of an optional argument within an | |
8615 * argument list. | |
8616 */ | |
8617 String get parameterName => _parameterName; | |
8618 | |
8619 /** | |
8620 * The name of the optional parameter being suggested. This field is omitted | |
8621 * if the suggestion is not the addition of an optional argument within an | |
8622 * argument list. | |
8623 */ | |
8624 void set parameterName(String value) { | |
8625 this._parameterName = value; | |
8626 } | |
8627 | |
8628 /** | |
8629 * The type of the options parameter being suggested. This field is omitted | |
8630 * if the parameterName field is omitted. | |
8631 */ | |
8632 String get parameterType => _parameterType; | |
8633 | |
8634 /** | |
8635 * The type of the options parameter being suggested. This field is omitted | |
8636 * if the parameterName field is omitted. | |
8637 */ | |
8638 void set parameterType(String value) { | |
8639 this._parameterType = value; | |
8640 } | |
8641 | |
8642 /** | |
8643 * The import to be added if the suggestion is out of scope and needs an | |
8644 * import to be added to be in scope. | |
8645 */ | |
8646 String get importUri => _importUri; | |
8647 | |
8648 /** | |
8649 * The import to be added if the suggestion is out of scope and needs an | |
8650 * import to be added to be in scope. | |
8651 */ | |
8652 void set importUri(String value) { | |
8653 this._importUri = value; | |
8654 } | |
8655 | |
8656 CompletionSuggestion(CompletionSuggestionKind kind, int relevance, String comp
letion, int selectionOffset, int selectionLength, bool isDeprecated, bool isPote
ntial, {String docSummary, String docComplete, String declaringType, Element ele
ment, String returnType, List<String> parameterNames, List<String> parameterType
s, int requiredParameterCount, bool hasNamedParameters, String parameterName, St
ring parameterType, String importUri}) { | |
8657 this.kind = kind; | |
8658 this.relevance = relevance; | |
8659 this.completion = completion; | |
8660 this.selectionOffset = selectionOffset; | |
8661 this.selectionLength = selectionLength; | |
8662 this.isDeprecated = isDeprecated; | |
8663 this.isPotential = isPotential; | |
8664 this.docSummary = docSummary; | |
8665 this.docComplete = docComplete; | |
8666 this.declaringType = declaringType; | |
8667 this.element = element; | |
8668 this.returnType = returnType; | |
8669 this.parameterNames = parameterNames; | |
8670 this.parameterTypes = parameterTypes; | |
8671 this.requiredParameterCount = requiredParameterCount; | |
8672 this.hasNamedParameters = hasNamedParameters; | |
8673 this.parameterName = parameterName; | |
8674 this.parameterType = parameterType; | |
8675 this.importUri = importUri; | |
8676 } | |
8677 | |
8678 factory CompletionSuggestion.fromJson(JsonDecoder jsonDecoder, String jsonPath
, Object json) { | |
8679 if (json == null) { | |
8680 json = {}; | |
8681 } | |
8682 if (json is Map) { | |
8683 CompletionSuggestionKind kind; | |
8684 if (json.containsKey("kind")) { | |
8685 kind = new CompletionSuggestionKind.fromJson(jsonDecoder, jsonPath + ".k
ind", json["kind"]); | |
8686 } else { | |
8687 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
8688 } | |
8689 int relevance; | |
8690 if (json.containsKey("relevance")) { | |
8691 relevance = jsonDecoder._decodeInt(jsonPath + ".relevance", json["releva
nce"]); | |
8692 } else { | |
8693 throw jsonDecoder.missingKey(jsonPath, "relevance"); | |
8694 } | |
8695 String completion; | |
8696 if (json.containsKey("completion")) { | |
8697 completion = jsonDecoder._decodeString(jsonPath + ".completion", json["c
ompletion"]); | |
8698 } else { | |
8699 throw jsonDecoder.missingKey(jsonPath, "completion"); | |
8700 } | |
8701 int selectionOffset; | |
8702 if (json.containsKey("selectionOffset")) { | |
8703 selectionOffset = jsonDecoder._decodeInt(jsonPath + ".selectionOffset",
json["selectionOffset"]); | |
8704 } else { | |
8705 throw jsonDecoder.missingKey(jsonPath, "selectionOffset"); | |
8706 } | |
8707 int selectionLength; | |
8708 if (json.containsKey("selectionLength")) { | |
8709 selectionLength = jsonDecoder._decodeInt(jsonPath + ".selectionLength",
json["selectionLength"]); | |
8710 } else { | |
8711 throw jsonDecoder.missingKey(jsonPath, "selectionLength"); | |
8712 } | |
8713 bool isDeprecated; | |
8714 if (json.containsKey("isDeprecated")) { | |
8715 isDeprecated = jsonDecoder._decodeBool(jsonPath + ".isDeprecated", json[
"isDeprecated"]); | |
8716 } else { | |
8717 throw jsonDecoder.missingKey(jsonPath, "isDeprecated"); | |
8718 } | |
8719 bool isPotential; | |
8720 if (json.containsKey("isPotential")) { | |
8721 isPotential = jsonDecoder._decodeBool(jsonPath + ".isPotential", json["i
sPotential"]); | |
8722 } else { | |
8723 throw jsonDecoder.missingKey(jsonPath, "isPotential"); | |
8724 } | |
8725 String docSummary; | |
8726 if (json.containsKey("docSummary")) { | |
8727 docSummary = jsonDecoder._decodeString(jsonPath + ".docSummary", json["d
ocSummary"]); | |
8728 } | |
8729 String docComplete; | |
8730 if (json.containsKey("docComplete")) { | |
8731 docComplete = jsonDecoder._decodeString(jsonPath + ".docComplete", json[
"docComplete"]); | |
8732 } | |
8733 String declaringType; | |
8734 if (json.containsKey("declaringType")) { | |
8735 declaringType = jsonDecoder._decodeString(jsonPath + ".declaringType", j
son["declaringType"]); | |
8736 } | |
8737 Element element; | |
8738 if (json.containsKey("element")) { | |
8739 element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json[
"element"]); | |
8740 } | |
8741 String returnType; | |
8742 if (json.containsKey("returnType")) { | |
8743 returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["r
eturnType"]); | |
8744 } | |
8745 List<String> parameterNames; | |
8746 if (json.containsKey("parameterNames")) { | |
8747 parameterNames = jsonDecoder._decodeList(jsonPath + ".parameterNames", j
son["parameterNames"], jsonDecoder._decodeString); | |
8748 } | |
8749 List<String> parameterTypes; | |
8750 if (json.containsKey("parameterTypes")) { | |
8751 parameterTypes = jsonDecoder._decodeList(jsonPath + ".parameterTypes", j
son["parameterTypes"], jsonDecoder._decodeString); | |
8752 } | |
8753 int requiredParameterCount; | |
8754 if (json.containsKey("requiredParameterCount")) { | |
8755 requiredParameterCount = jsonDecoder._decodeInt(jsonPath + ".requiredPar
ameterCount", json["requiredParameterCount"]); | |
8756 } | |
8757 bool hasNamedParameters; | |
8758 if (json.containsKey("hasNamedParameters")) { | |
8759 hasNamedParameters = jsonDecoder._decodeBool(jsonPath + ".hasNamedParame
ters", json["hasNamedParameters"]); | |
8760 } | |
8761 String parameterName; | |
8762 if (json.containsKey("parameterName")) { | |
8763 parameterName = jsonDecoder._decodeString(jsonPath + ".parameterName", j
son["parameterName"]); | |
8764 } | |
8765 String parameterType; | |
8766 if (json.containsKey("parameterType")) { | |
8767 parameterType = jsonDecoder._decodeString(jsonPath + ".parameterType", j
son["parameterType"]); | |
8768 } | |
8769 String importUri; | |
8770 if (json.containsKey("importUri")) { | |
8771 importUri = jsonDecoder._decodeString(jsonPath + ".importUri", json["imp
ortUri"]); | |
8772 } | |
8773 return new CompletionSuggestion(kind, relevance, completion, selectionOffs
et, selectionLength, isDeprecated, isPotential, docSummary: docSummary, docCompl
ete: docComplete, declaringType: declaringType, element: element, returnType: re
turnType, parameterNames: parameterNames, parameterTypes: parameterTypes, requir
edParameterCount: requiredParameterCount, hasNamedParameters: hasNamedParameters
, parameterName: parameterName, parameterType: parameterType, importUri: importU
ri); | |
8774 } else { | |
8775 throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestion", json); | |
8776 } | |
8777 } | |
8778 | |
8779 Map<String, dynamic> toJson() { | |
8780 Map<String, dynamic> result = {}; | |
8781 result["kind"] = kind.toJson(); | |
8782 result["relevance"] = relevance; | |
8783 result["completion"] = completion; | |
8784 result["selectionOffset"] = selectionOffset; | |
8785 result["selectionLength"] = selectionLength; | |
8786 result["isDeprecated"] = isDeprecated; | |
8787 result["isPotential"] = isPotential; | |
8788 if (docSummary != null) { | |
8789 result["docSummary"] = docSummary; | |
8790 } | |
8791 if (docComplete != null) { | |
8792 result["docComplete"] = docComplete; | |
8793 } | |
8794 if (declaringType != null) { | |
8795 result["declaringType"] = declaringType; | |
8796 } | |
8797 if (element != null) { | |
8798 result["element"] = element.toJson(); | |
8799 } | |
8800 if (returnType != null) { | |
8801 result["returnType"] = returnType; | |
8802 } | |
8803 if (parameterNames != null) { | |
8804 result["parameterNames"] = parameterNames; | |
8805 } | |
8806 if (parameterTypes != null) { | |
8807 result["parameterTypes"] = parameterTypes; | |
8808 } | |
8809 if (requiredParameterCount != null) { | |
8810 result["requiredParameterCount"] = requiredParameterCount; | |
8811 } | |
8812 if (hasNamedParameters != null) { | |
8813 result["hasNamedParameters"] = hasNamedParameters; | |
8814 } | |
8815 if (parameterName != null) { | |
8816 result["parameterName"] = parameterName; | |
8817 } | |
8818 if (parameterType != null) { | |
8819 result["parameterType"] = parameterType; | |
8820 } | |
8821 if (importUri != null) { | |
8822 result["importUri"] = importUri; | |
8823 } | |
8824 return result; | |
8825 } | |
8826 | |
8827 @override | |
8828 String toString() => JSON.encode(toJson()); | |
8829 | |
8830 @override | |
8831 bool operator==(other) { | |
8832 if (other is CompletionSuggestion) { | |
8833 return kind == other.kind && | |
8834 relevance == other.relevance && | |
8835 completion == other.completion && | |
8836 selectionOffset == other.selectionOffset && | |
8837 selectionLength == other.selectionLength && | |
8838 isDeprecated == other.isDeprecated && | |
8839 isPotential == other.isPotential && | |
8840 docSummary == other.docSummary && | |
8841 docComplete == other.docComplete && | |
8842 declaringType == other.declaringType && | |
8843 element == other.element && | |
8844 returnType == other.returnType && | |
8845 _listEqual(parameterNames, other.parameterNames, (String a, String b)
=> a == b) && | |
8846 _listEqual(parameterTypes, other.parameterTypes, (String a, String b)
=> a == b) && | |
8847 requiredParameterCount == other.requiredParameterCount && | |
8848 hasNamedParameters == other.hasNamedParameters && | |
8849 parameterName == other.parameterName && | |
8850 parameterType == other.parameterType && | |
8851 importUri == other.importUri; | |
8852 } | |
8853 return false; | |
8854 } | |
8855 | |
8856 @override | |
8857 int get hashCode { | |
8858 int hash = 0; | |
8859 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
8860 hash = _JenkinsSmiHash.combine(hash, relevance.hashCode); | |
8861 hash = _JenkinsSmiHash.combine(hash, completion.hashCode); | |
8862 hash = _JenkinsSmiHash.combine(hash, selectionOffset.hashCode); | |
8863 hash = _JenkinsSmiHash.combine(hash, selectionLength.hashCode); | |
8864 hash = _JenkinsSmiHash.combine(hash, isDeprecated.hashCode); | |
8865 hash = _JenkinsSmiHash.combine(hash, isPotential.hashCode); | |
8866 hash = _JenkinsSmiHash.combine(hash, docSummary.hashCode); | |
8867 hash = _JenkinsSmiHash.combine(hash, docComplete.hashCode); | |
8868 hash = _JenkinsSmiHash.combine(hash, declaringType.hashCode); | |
8869 hash = _JenkinsSmiHash.combine(hash, element.hashCode); | |
8870 hash = _JenkinsSmiHash.combine(hash, returnType.hashCode); | |
8871 hash = _JenkinsSmiHash.combine(hash, parameterNames.hashCode); | |
8872 hash = _JenkinsSmiHash.combine(hash, parameterTypes.hashCode); | |
8873 hash = _JenkinsSmiHash.combine(hash, requiredParameterCount.hashCode); | |
8874 hash = _JenkinsSmiHash.combine(hash, hasNamedParameters.hashCode); | |
8875 hash = _JenkinsSmiHash.combine(hash, parameterName.hashCode); | |
8876 hash = _JenkinsSmiHash.combine(hash, parameterType.hashCode); | |
8877 hash = _JenkinsSmiHash.combine(hash, importUri.hashCode); | |
8878 return _JenkinsSmiHash.finish(hash); | |
8879 } | |
8880 } | |
8881 | |
8882 /** | |
8883 * CompletionSuggestionKind | |
8884 * | |
8885 * enum { | |
8886 * ARGUMENT_LIST | |
8887 * IMPORT | |
8888 * IDENTIFIER | |
8889 * INVOCATION | |
8890 * KEYWORD | |
8891 * NAMED_ARGUMENT | |
8892 * OPTIONAL_ARGUMENT | |
8893 * PARAMETER | |
8894 * } | |
8895 */ | |
8896 class CompletionSuggestionKind implements Enum { | |
8897 /** | |
8898 * A list of arguments for the method or function that is being invoked. For | |
8899 * this suggestion kind, the completion field is a textual representation of | |
8900 * the invocation and the parameterNames, parameterTypes, and | |
8901 * requiredParameterCount attributes are defined. | |
8902 */ | |
8903 static const ARGUMENT_LIST = const CompletionSuggestionKind._("ARGUMENT_LIST")
; | |
8904 | |
8905 static const IMPORT = const CompletionSuggestionKind._("IMPORT"); | |
8906 | |
8907 /** | |
8908 * The element identifier should be inserted at the completion location. For | |
8909 * example "someMethod" in import 'myLib.dart' show someMethod; . For | |
8910 * suggestions of this kind, the element attribute is defined and the | |
8911 * completion field is the element's identifier. | |
8912 */ | |
8913 static const IDENTIFIER = const CompletionSuggestionKind._("IDENTIFIER"); | |
8914 | |
8915 /** | |
8916 * The element is being invoked at the completion location. For example, | |
8917 * "someMethod" in x.someMethod(); . For suggestions of this kind, the | |
8918 * element attribute is defined and the completion field is the element's | |
8919 * identifier. | |
8920 */ | |
8921 static const INVOCATION = const CompletionSuggestionKind._("INVOCATION"); | |
8922 | |
8923 /** | |
8924 * A keyword is being suggested. For suggestions of this kind, the completion | |
8925 * is the keyword. | |
8926 */ | |
8927 static const KEYWORD = const CompletionSuggestionKind._("KEYWORD"); | |
8928 | |
8929 /** | |
8930 * A named argument for the current callsite is being suggested. For | |
8931 * suggestions of this kind, the completion is the named argument identifier | |
8932 * including a trailing ':' and space. | |
8933 */ | |
8934 static const NAMED_ARGUMENT = const CompletionSuggestionKind._("NAMED_ARGUMENT
"); | |
8935 | |
8936 static const OPTIONAL_ARGUMENT = const CompletionSuggestionKind._("OPTIONAL_AR
GUMENT"); | |
8937 | |
8938 static const PARAMETER = const CompletionSuggestionKind._("PARAMETER"); | |
8939 | |
8940 /** | |
8941 * A list containing all of the enum values that are defined. | |
8942 */ | |
8943 static const List<CompletionSuggestionKind> VALUES = const <CompletionSuggesti
onKind>[ARGUMENT_LIST, IMPORT, IDENTIFIER, INVOCATION, KEYWORD, NAMED_ARGUMENT,
OPTIONAL_ARGUMENT, PARAMETER]; | |
8944 | |
8945 final String name; | |
8946 | |
8947 const CompletionSuggestionKind._(this.name); | |
8948 | |
8949 factory CompletionSuggestionKind(String name) { | |
8950 switch (name) { | |
8951 case "ARGUMENT_LIST": | |
8952 return ARGUMENT_LIST; | |
8953 case "IMPORT": | |
8954 return IMPORT; | |
8955 case "IDENTIFIER": | |
8956 return IDENTIFIER; | |
8957 case "INVOCATION": | |
8958 return INVOCATION; | |
8959 case "KEYWORD": | |
8960 return KEYWORD; | |
8961 case "NAMED_ARGUMENT": | |
8962 return NAMED_ARGUMENT; | |
8963 case "OPTIONAL_ARGUMENT": | |
8964 return OPTIONAL_ARGUMENT; | |
8965 case "PARAMETER": | |
8966 return PARAMETER; | |
8967 } | |
8968 throw new Exception('Illegal enum value: $name'); | |
8969 } | |
8970 | |
8971 factory CompletionSuggestionKind.fromJson(JsonDecoder jsonDecoder, String json
Path, Object json) { | |
8972 if (json is String) { | |
8973 try { | |
8974 return new CompletionSuggestionKind(json); | |
8975 } catch(_) { | |
8976 // Fall through | |
8977 } | |
8978 } | |
8979 throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestionKind", json); | |
8980 } | |
8981 | |
8982 @override | |
8983 String toString() => "CompletionSuggestionKind.$name"; | |
8984 | |
8985 String toJson() => name; | |
8986 } | |
8987 | |
8988 /** | |
8989 * Element | |
8990 * | |
8991 * { | |
8992 * "kind": ElementKind | |
8993 * "name": String | |
8994 * "location": optional Location | |
8995 * "flags": int | |
8996 * "parameters": optional String | |
8997 * "returnType": optional String | |
8998 * "typeParameters": optional String | |
8999 * } | |
9000 */ | |
9001 class Element implements HasToJson { | |
9002 static const int FLAG_ABSTRACT = 0x01; | |
9003 static const int FLAG_CONST = 0x02; | |
9004 static const int FLAG_FINAL = 0x04; | |
9005 static const int FLAG_STATIC = 0x08; | |
9006 static const int FLAG_PRIVATE = 0x10; | |
9007 static const int FLAG_DEPRECATED = 0x20; | |
9008 | |
9009 static int makeFlags({isAbstract: false, isConst: false, isFinal: false, isSta
tic: false, isPrivate: false, isDeprecated: false}) { | |
9010 int flags = 0; | |
9011 if (isAbstract) flags |= FLAG_ABSTRACT; | |
9012 if (isConst) flags |= FLAG_CONST; | |
9013 if (isFinal) flags |= FLAG_FINAL; | |
9014 if (isStatic) flags |= FLAG_STATIC; | |
9015 if (isPrivate) flags |= FLAG_PRIVATE; | |
9016 if (isDeprecated) flags |= FLAG_DEPRECATED; | |
9017 return flags; | |
9018 } | |
9019 | |
9020 ElementKind _kind; | |
9021 | |
9022 String _name; | |
9023 | |
9024 Location _location; | |
9025 | |
9026 int _flags; | |
9027 | |
9028 String _parameters; | |
9029 | |
9030 String _returnType; | |
9031 | |
9032 String _typeParameters; | |
9033 | |
9034 /** | |
9035 * The kind of the element. | |
9036 */ | |
9037 ElementKind get kind => _kind; | |
9038 | |
9039 /** | |
9040 * The kind of the element. | |
9041 */ | |
9042 void set kind(ElementKind value) { | |
9043 assert(value != null); | |
9044 this._kind = value; | |
9045 } | |
9046 | |
9047 /** | |
9048 * The name of the element. This is typically used as the label in the | |
9049 * outline. | |
9050 */ | |
9051 String get name => _name; | |
9052 | |
9053 /** | |
9054 * The name of the element. This is typically used as the label in the | |
9055 * outline. | |
9056 */ | |
9057 void set name(String value) { | |
9058 assert(value != null); | |
9059 this._name = value; | |
9060 } | |
9061 | |
9062 /** | |
9063 * The location of the name in the declaration of the element. | |
9064 */ | |
9065 Location get location => _location; | |
9066 | |
9067 /** | |
9068 * The location of the name in the declaration of the element. | |
9069 */ | |
9070 void set location(Location value) { | |
9071 this._location = value; | |
9072 } | |
9073 | |
9074 /** | |
9075 * A bit-map containing the following flags: | |
9076 * | |
9077 * - 0x01 - set if the element is explicitly or implicitly abstract | |
9078 * - 0x02 - set if the element was declared to be ‘const’ | |
9079 * - 0x04 - set if the element was declared to be ‘final’ | |
9080 * - 0x08 - set if the element is a static member of a class or is a | |
9081 * top-level function or field | |
9082 * - 0x10 - set if the element is private | |
9083 * - 0x20 - set if the element is deprecated | |
9084 */ | |
9085 int get flags => _flags; | |
9086 | |
9087 /** | |
9088 * A bit-map containing the following flags: | |
9089 * | |
9090 * - 0x01 - set if the element is explicitly or implicitly abstract | |
9091 * - 0x02 - set if the element was declared to be ‘const’ | |
9092 * - 0x04 - set if the element was declared to be ‘final’ | |
9093 * - 0x08 - set if the element is a static member of a class or is a | |
9094 * top-level function or field | |
9095 * - 0x10 - set if the element is private | |
9096 * - 0x20 - set if the element is deprecated | |
9097 */ | |
9098 void set flags(int value) { | |
9099 assert(value != null); | |
9100 this._flags = value; | |
9101 } | |
9102 | |
9103 /** | |
9104 * The parameter list for the element. If the element is not a method or | |
9105 * function this field will not be defined. If the element doesn't have | |
9106 * parameters (e.g. getter), this field will not be defined. If the element | |
9107 * has zero parameters, this field will have a value of "()". | |
9108 */ | |
9109 String get parameters => _parameters; | |
9110 | |
9111 /** | |
9112 * The parameter list for the element. If the element is not a method or | |
9113 * function this field will not be defined. If the element doesn't have | |
9114 * parameters (e.g. getter), this field will not be defined. If the element | |
9115 * has zero parameters, this field will have a value of "()". | |
9116 */ | |
9117 void set parameters(String value) { | |
9118 this._parameters = value; | |
9119 } | |
9120 | |
9121 /** | |
9122 * The return type of the element. If the element is not a method or function | |
9123 * this field will not be defined. If the element does not have a declared | |
9124 * return type, this field will contain an empty string. | |
9125 */ | |
9126 String get returnType => _returnType; | |
9127 | |
9128 /** | |
9129 * The return type of the element. If the element is not a method or function | |
9130 * this field will not be defined. If the element does not have a declared | |
9131 * return type, this field will contain an empty string. | |
9132 */ | |
9133 void set returnType(String value) { | |
9134 this._returnType = value; | |
9135 } | |
9136 | |
9137 /** | |
9138 * The type parameter list for the element. If the element doesn't have type | |
9139 * parameters, this field will not be defined. | |
9140 */ | |
9141 String get typeParameters => _typeParameters; | |
9142 | |
9143 /** | |
9144 * The type parameter list for the element. If the element doesn't have type | |
9145 * parameters, this field will not be defined. | |
9146 */ | |
9147 void set typeParameters(String value) { | |
9148 this._typeParameters = value; | |
9149 } | |
9150 | |
9151 Element(ElementKind kind, String name, int flags, {Location location, String p
arameters, String returnType, String typeParameters}) { | |
9152 this.kind = kind; | |
9153 this.name = name; | |
9154 this.location = location; | |
9155 this.flags = flags; | |
9156 this.parameters = parameters; | |
9157 this.returnType = returnType; | |
9158 this.typeParameters = typeParameters; | |
9159 } | |
9160 | |
9161 factory Element.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json
) { | |
9162 if (json == null) { | |
9163 json = {}; | |
9164 } | |
9165 if (json is Map) { | |
9166 ElementKind kind; | |
9167 if (json.containsKey("kind")) { | |
9168 kind = new ElementKind.fromJson(jsonDecoder, jsonPath + ".kind", json["k
ind"]); | |
9169 } else { | |
9170 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
9171 } | |
9172 String name; | |
9173 if (json.containsKey("name")) { | |
9174 name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]); | |
9175 } else { | |
9176 throw jsonDecoder.missingKey(jsonPath, "name"); | |
9177 } | |
9178 Location location; | |
9179 if (json.containsKey("location")) { | |
9180 location = new Location.fromJson(jsonDecoder, jsonPath + ".location", js
on["location"]); | |
9181 } | |
9182 int flags; | |
9183 if (json.containsKey("flags")) { | |
9184 flags = jsonDecoder._decodeInt(jsonPath + ".flags", json["flags"]); | |
9185 } else { | |
9186 throw jsonDecoder.missingKey(jsonPath, "flags"); | |
9187 } | |
9188 String parameters; | |
9189 if (json.containsKey("parameters")) { | |
9190 parameters = jsonDecoder._decodeString(jsonPath + ".parameters", json["p
arameters"]); | |
9191 } | |
9192 String returnType; | |
9193 if (json.containsKey("returnType")) { | |
9194 returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["r
eturnType"]); | |
9195 } | |
9196 String typeParameters; | |
9197 if (json.containsKey("typeParameters")) { | |
9198 typeParameters = jsonDecoder._decodeString(jsonPath + ".typeParameters",
json["typeParameters"]); | |
9199 } | |
9200 return new Element(kind, name, flags, location: location, parameters: para
meters, returnType: returnType, typeParameters: typeParameters); | |
9201 } else { | |
9202 throw jsonDecoder.mismatch(jsonPath, "Element", json); | |
9203 } | |
9204 } | |
9205 | |
9206 bool get isAbstract => (flags & FLAG_ABSTRACT) != 0; | |
9207 bool get isConst => (flags & FLAG_CONST) != 0; | |
9208 bool get isFinal => (flags & FLAG_FINAL) != 0; | |
9209 bool get isStatic => (flags & FLAG_STATIC) != 0; | |
9210 bool get isPrivate => (flags & FLAG_PRIVATE) != 0; | |
9211 bool get isDeprecated => (flags & FLAG_DEPRECATED) != 0; | |
9212 | |
9213 Map<String, dynamic> toJson() { | |
9214 Map<String, dynamic> result = {}; | |
9215 result["kind"] = kind.toJson(); | |
9216 result["name"] = name; | |
9217 if (location != null) { | |
9218 result["location"] = location.toJson(); | |
9219 } | |
9220 result["flags"] = flags; | |
9221 if (parameters != null) { | |
9222 result["parameters"] = parameters; | |
9223 } | |
9224 if (returnType != null) { | |
9225 result["returnType"] = returnType; | |
9226 } | |
9227 if (typeParameters != null) { | |
9228 result["typeParameters"] = typeParameters; | |
9229 } | |
9230 return result; | |
9231 } | |
9232 | |
9233 @override | |
9234 String toString() => JSON.encode(toJson()); | |
9235 | |
9236 @override | |
9237 bool operator==(other) { | |
9238 if (other is Element) { | |
9239 return kind == other.kind && | |
9240 name == other.name && | |
9241 location == other.location && | |
9242 flags == other.flags && | |
9243 parameters == other.parameters && | |
9244 returnType == other.returnType && | |
9245 typeParameters == other.typeParameters; | |
9246 } | |
9247 return false; | |
9248 } | |
9249 | |
9250 @override | |
9251 int get hashCode { | |
9252 int hash = 0; | |
9253 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
9254 hash = _JenkinsSmiHash.combine(hash, name.hashCode); | |
9255 hash = _JenkinsSmiHash.combine(hash, location.hashCode); | |
9256 hash = _JenkinsSmiHash.combine(hash, flags.hashCode); | |
9257 hash = _JenkinsSmiHash.combine(hash, parameters.hashCode); | |
9258 hash = _JenkinsSmiHash.combine(hash, returnType.hashCode); | |
9259 hash = _JenkinsSmiHash.combine(hash, typeParameters.hashCode); | |
9260 return _JenkinsSmiHash.finish(hash); | |
9261 } | |
9262 } | |
9263 | |
9264 /** | |
9265 * ElementKind | |
9266 * | |
9267 * enum { | |
9268 * CLASS | |
9269 * CLASS_TYPE_ALIAS | |
9270 * COMPILATION_UNIT | |
9271 * CONSTRUCTOR | |
9272 * ENUM | |
9273 * ENUM_CONSTANT | |
9274 * FIELD | |
9275 * FUNCTION | |
9276 * FUNCTION_TYPE_ALIAS | |
9277 * GETTER | |
9278 * LABEL | |
9279 * LIBRARY | |
9280 * LOCAL_VARIABLE | |
9281 * METHOD | |
9282 * PARAMETER | |
9283 * PREFIX | |
9284 * SETTER | |
9285 * TOP_LEVEL_VARIABLE | |
9286 * TYPE_PARAMETER | |
9287 * UNIT_TEST_GROUP | |
9288 * UNIT_TEST_TEST | |
9289 * UNKNOWN | |
9290 * } | |
9291 */ | |
9292 class ElementKind implements Enum { | |
9293 static const CLASS = const ElementKind._("CLASS"); | |
9294 | |
9295 static const CLASS_TYPE_ALIAS = const ElementKind._("CLASS_TYPE_ALIAS"); | |
9296 | |
9297 static const COMPILATION_UNIT = const ElementKind._("COMPILATION_UNIT"); | |
9298 | |
9299 static const CONSTRUCTOR = const ElementKind._("CONSTRUCTOR"); | |
9300 | |
9301 static const ENUM = const ElementKind._("ENUM"); | |
9302 | |
9303 static const ENUM_CONSTANT = const ElementKind._("ENUM_CONSTANT"); | |
9304 | |
9305 static const FIELD = const ElementKind._("FIELD"); | |
9306 | |
9307 static const FUNCTION = const ElementKind._("FUNCTION"); | |
9308 | |
9309 static const FUNCTION_TYPE_ALIAS = const ElementKind._("FUNCTION_TYPE_ALIAS"); | |
9310 | |
9311 static const GETTER = const ElementKind._("GETTER"); | |
9312 | |
9313 static const LABEL = const ElementKind._("LABEL"); | |
9314 | |
9315 static const LIBRARY = const ElementKind._("LIBRARY"); | |
9316 | |
9317 static const LOCAL_VARIABLE = const ElementKind._("LOCAL_VARIABLE"); | |
9318 | |
9319 static const METHOD = const ElementKind._("METHOD"); | |
9320 | |
9321 static const PARAMETER = const ElementKind._("PARAMETER"); | |
9322 | |
9323 static const PREFIX = const ElementKind._("PREFIX"); | |
9324 | |
9325 static const SETTER = const ElementKind._("SETTER"); | |
9326 | |
9327 static const TOP_LEVEL_VARIABLE = const ElementKind._("TOP_LEVEL_VARIABLE"); | |
9328 | |
9329 static const TYPE_PARAMETER = const ElementKind._("TYPE_PARAMETER"); | |
9330 | |
9331 static const UNIT_TEST_GROUP = const ElementKind._("UNIT_TEST_GROUP"); | |
9332 | |
9333 static const UNIT_TEST_TEST = const ElementKind._("UNIT_TEST_TEST"); | |
9334 | |
9335 static const UNKNOWN = const ElementKind._("UNKNOWN"); | |
9336 | |
9337 /** | |
9338 * A list containing all of the enum values that are defined. | |
9339 */ | |
9340 static const List<ElementKind> VALUES = const <ElementKind>[CLASS, CLASS_TYPE_
ALIAS, COMPILATION_UNIT, CONSTRUCTOR, ENUM, ENUM_CONSTANT, FIELD, FUNCTION, FUNC
TION_TYPE_ALIAS, GETTER, LABEL, LIBRARY, LOCAL_VARIABLE, METHOD, PARAMETER, PREF
IX, SETTER, TOP_LEVEL_VARIABLE, TYPE_PARAMETER, UNIT_TEST_GROUP, UNIT_TEST_TEST,
UNKNOWN]; | |
9341 | |
9342 final String name; | |
9343 | |
9344 const ElementKind._(this.name); | |
9345 | |
9346 factory ElementKind(String name) { | |
9347 switch (name) { | |
9348 case "CLASS": | |
9349 return CLASS; | |
9350 case "CLASS_TYPE_ALIAS": | |
9351 return CLASS_TYPE_ALIAS; | |
9352 case "COMPILATION_UNIT": | |
9353 return COMPILATION_UNIT; | |
9354 case "CONSTRUCTOR": | |
9355 return CONSTRUCTOR; | |
9356 case "ENUM": | |
9357 return ENUM; | |
9358 case "ENUM_CONSTANT": | |
9359 return ENUM_CONSTANT; | |
9360 case "FIELD": | |
9361 return FIELD; | |
9362 case "FUNCTION": | |
9363 return FUNCTION; | |
9364 case "FUNCTION_TYPE_ALIAS": | |
9365 return FUNCTION_TYPE_ALIAS; | |
9366 case "GETTER": | |
9367 return GETTER; | |
9368 case "LABEL": | |
9369 return LABEL; | |
9370 case "LIBRARY": | |
9371 return LIBRARY; | |
9372 case "LOCAL_VARIABLE": | |
9373 return LOCAL_VARIABLE; | |
9374 case "METHOD": | |
9375 return METHOD; | |
9376 case "PARAMETER": | |
9377 return PARAMETER; | |
9378 case "PREFIX": | |
9379 return PREFIX; | |
9380 case "SETTER": | |
9381 return SETTER; | |
9382 case "TOP_LEVEL_VARIABLE": | |
9383 return TOP_LEVEL_VARIABLE; | |
9384 case "TYPE_PARAMETER": | |
9385 return TYPE_PARAMETER; | |
9386 case "UNIT_TEST_GROUP": | |
9387 return UNIT_TEST_GROUP; | |
9388 case "UNIT_TEST_TEST": | |
9389 return UNIT_TEST_TEST; | |
9390 case "UNKNOWN": | |
9391 return UNKNOWN; | |
9392 } | |
9393 throw new Exception('Illegal enum value: $name'); | |
9394 } | |
9395 | |
9396 factory ElementKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object
json) { | |
9397 if (json is String) { | |
9398 try { | |
9399 return new ElementKind(json); | |
9400 } catch(_) { | |
9401 // Fall through | |
9402 } | |
9403 } | |
9404 throw jsonDecoder.mismatch(jsonPath, "ElementKind", json); | |
9405 } | |
9406 | |
9407 @override | |
9408 String toString() => "ElementKind.$name"; | |
9409 | |
9410 String toJson() => name; | |
9411 } | |
9412 | |
9413 /** | |
9414 * ExecutableFile | |
9415 * | |
9416 * { | |
9417 * "file": FilePath | |
9418 * "kind": ExecutableKind | |
9419 * } | |
9420 */ | |
9421 class ExecutableFile implements HasToJson { | |
9422 String _file; | |
9423 | |
9424 ExecutableKind _kind; | |
9425 | |
9426 /** | |
9427 * The path of the executable file. | |
9428 */ | |
9429 String get file => _file; | |
9430 | |
9431 /** | |
9432 * The path of the executable file. | |
9433 */ | |
9434 void set file(String value) { | |
9435 assert(value != null); | |
9436 this._file = value; | |
9437 } | |
9438 | |
9439 /** | |
9440 * The kind of the executable file. | |
9441 */ | |
9442 ExecutableKind get kind => _kind; | |
9443 | |
9444 /** | |
9445 * The kind of the executable file. | |
9446 */ | |
9447 void set kind(ExecutableKind value) { | |
9448 assert(value != null); | |
9449 this._kind = value; | |
9450 } | |
9451 | |
9452 ExecutableFile(String file, ExecutableKind kind) { | |
9453 this.file = file; | |
9454 this.kind = kind; | |
9455 } | |
9456 | |
9457 factory ExecutableFile.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obje
ct json) { | |
9458 if (json == null) { | |
9459 json = {}; | |
9460 } | |
9461 if (json is Map) { | |
9462 String file; | |
9463 if (json.containsKey("file")) { | |
9464 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
9465 } else { | |
9466 throw jsonDecoder.missingKey(jsonPath, "file"); | |
9467 } | |
9468 ExecutableKind kind; | |
9469 if (json.containsKey("kind")) { | |
9470 kind = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".kind", json
["kind"]); | |
9471 } else { | |
9472 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
9473 } | |
9474 return new ExecutableFile(file, kind); | |
9475 } else { | |
9476 throw jsonDecoder.mismatch(jsonPath, "ExecutableFile", json); | |
9477 } | |
9478 } | |
9479 | |
9480 Map<String, dynamic> toJson() { | |
9481 Map<String, dynamic> result = {}; | |
9482 result["file"] = file; | |
9483 result["kind"] = kind.toJson(); | |
9484 return result; | |
9485 } | |
9486 | |
9487 @override | |
9488 String toString() => JSON.encode(toJson()); | |
9489 | |
9490 @override | |
9491 bool operator==(other) { | |
9492 if (other is ExecutableFile) { | |
9493 return file == other.file && | |
9494 kind == other.kind; | |
9495 } | |
9496 return false; | |
9497 } | |
9498 | |
9499 @override | |
9500 int get hashCode { | |
9501 int hash = 0; | |
9502 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
9503 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
9504 return _JenkinsSmiHash.finish(hash); | |
9505 } | |
9506 } | |
9507 | |
9508 /** | |
9509 * ExecutableKind | |
9510 * | |
9511 * enum { | |
9512 * CLIENT | |
9513 * EITHER | |
9514 * NOT_EXECUTABLE | |
9515 * SERVER | |
9516 * } | |
9517 */ | |
9518 class ExecutableKind implements Enum { | |
9519 static const CLIENT = const ExecutableKind._("CLIENT"); | |
9520 | |
9521 static const EITHER = const ExecutableKind._("EITHER"); | |
9522 | |
9523 static const NOT_EXECUTABLE = const ExecutableKind._("NOT_EXECUTABLE"); | |
9524 | |
9525 static const SERVER = const ExecutableKind._("SERVER"); | |
9526 | |
9527 /** | |
9528 * A list containing all of the enum values that are defined. | |
9529 */ | |
9530 static const List<ExecutableKind> VALUES = const <ExecutableKind>[CLIENT, EITH
ER, NOT_EXECUTABLE, SERVER]; | |
9531 | |
9532 final String name; | |
9533 | |
9534 const ExecutableKind._(this.name); | |
9535 | |
9536 factory ExecutableKind(String name) { | |
9537 switch (name) { | |
9538 case "CLIENT": | |
9539 return CLIENT; | |
9540 case "EITHER": | |
9541 return EITHER; | |
9542 case "NOT_EXECUTABLE": | |
9543 return NOT_EXECUTABLE; | |
9544 case "SERVER": | |
9545 return SERVER; | |
9546 } | |
9547 throw new Exception('Illegal enum value: $name'); | |
9548 } | |
9549 | |
9550 factory ExecutableKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obje
ct json) { | |
9551 if (json is String) { | |
9552 try { | |
9553 return new ExecutableKind(json); | |
9554 } catch(_) { | |
9555 // Fall through | |
9556 } | |
9557 } | |
9558 throw jsonDecoder.mismatch(jsonPath, "ExecutableKind", json); | |
9559 } | |
9560 | |
9561 @override | |
9562 String toString() => "ExecutableKind.$name"; | |
9563 | |
9564 String toJson() => name; | |
9565 } | |
9566 | |
9567 /** | |
9568 * ExecutionService | |
9569 * | |
9570 * enum { | |
9571 * LAUNCH_DATA | |
9572 * } | |
9573 */ | |
9574 class ExecutionService implements Enum { | |
9575 static const LAUNCH_DATA = const ExecutionService._("LAUNCH_DATA"); | |
9576 | |
9577 /** | |
9578 * A list containing all of the enum values that are defined. | |
9579 */ | |
9580 static const List<ExecutionService> VALUES = const <ExecutionService>[LAUNCH_D
ATA]; | |
9581 | |
9582 final String name; | |
9583 | |
9584 const ExecutionService._(this.name); | |
9585 | |
9586 factory ExecutionService(String name) { | |
9587 switch (name) { | |
9588 case "LAUNCH_DATA": | |
9589 return LAUNCH_DATA; | |
9590 } | |
9591 throw new Exception('Illegal enum value: $name'); | |
9592 } | |
9593 | |
9594 factory ExecutionService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
9595 if (json is String) { | |
9596 try { | |
9597 return new ExecutionService(json); | |
9598 } catch(_) { | |
9599 // Fall through | |
9600 } | |
9601 } | |
9602 throw jsonDecoder.mismatch(jsonPath, "ExecutionService", json); | |
9603 } | |
9604 | |
9605 @override | |
9606 String toString() => "ExecutionService.$name"; | |
9607 | |
9608 String toJson() => name; | |
9609 } | |
9610 | |
9611 /** | |
9612 * FileKind | |
9613 * | |
9614 * enum { | |
9615 * LIBRARY | |
9616 * PART | |
9617 * } | |
9618 */ | |
9619 class FileKind implements Enum { | |
9620 static const LIBRARY = const FileKind._("LIBRARY"); | |
9621 | |
9622 static const PART = const FileKind._("PART"); | |
9623 | |
9624 /** | |
9625 * A list containing all of the enum values that are defined. | |
9626 */ | |
9627 static const List<FileKind> VALUES = const <FileKind>[LIBRARY, PART]; | |
9628 | |
9629 final String name; | |
9630 | |
9631 const FileKind._(this.name); | |
9632 | |
9633 factory FileKind(String name) { | |
9634 switch (name) { | |
9635 case "LIBRARY": | |
9636 return LIBRARY; | |
9637 case "PART": | |
9638 return PART; | |
9639 } | |
9640 throw new Exception('Illegal enum value: $name'); | |
9641 } | |
9642 | |
9643 factory FileKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object jso
n) { | |
9644 if (json is String) { | |
9645 try { | |
9646 return new FileKind(json); | |
9647 } catch(_) { | |
9648 // Fall through | |
9649 } | |
9650 } | |
9651 throw jsonDecoder.mismatch(jsonPath, "FileKind", json); | |
9652 } | |
9653 | |
9654 @override | |
9655 String toString() => "FileKind.$name"; | |
9656 | |
9657 String toJson() => name; | |
9658 } | |
9659 | |
9660 /** | |
9661 * FoldingKind | |
9662 * | |
9663 * enum { | |
9664 * COMMENT | |
9665 * CLASS_MEMBER | |
9666 * DIRECTIVES | |
9667 * DOCUMENTATION_COMMENT | |
9668 * TOP_LEVEL_DECLARATION | |
9669 * } | |
9670 */ | |
9671 class FoldingKind implements Enum { | |
9672 static const COMMENT = const FoldingKind._("COMMENT"); | |
9673 | |
9674 static const CLASS_MEMBER = const FoldingKind._("CLASS_MEMBER"); | |
9675 | |
9676 static const DIRECTIVES = const FoldingKind._("DIRECTIVES"); | |
9677 | |
9678 static const DOCUMENTATION_COMMENT = const FoldingKind._("DOCUMENTATION_COMMEN
T"); | |
9679 | |
9680 static const TOP_LEVEL_DECLARATION = const FoldingKind._("TOP_LEVEL_DECLARATIO
N"); | |
9681 | |
9682 /** | |
9683 * A list containing all of the enum values that are defined. | |
9684 */ | |
9685 static const List<FoldingKind> VALUES = const <FoldingKind>[COMMENT, CLASS_MEM
BER, DIRECTIVES, DOCUMENTATION_COMMENT, TOP_LEVEL_DECLARATION]; | |
9686 | |
9687 final String name; | |
9688 | |
9689 const FoldingKind._(this.name); | |
9690 | |
9691 factory FoldingKind(String name) { | |
9692 switch (name) { | |
9693 case "COMMENT": | |
9694 return COMMENT; | |
9695 case "CLASS_MEMBER": | |
9696 return CLASS_MEMBER; | |
9697 case "DIRECTIVES": | |
9698 return DIRECTIVES; | |
9699 case "DOCUMENTATION_COMMENT": | |
9700 return DOCUMENTATION_COMMENT; | |
9701 case "TOP_LEVEL_DECLARATION": | |
9702 return TOP_LEVEL_DECLARATION; | |
9703 } | |
9704 throw new Exception('Illegal enum value: $name'); | |
9705 } | |
9706 | |
9707 factory FoldingKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object
json) { | |
9708 if (json is String) { | |
9709 try { | |
9710 return new FoldingKind(json); | |
9711 } catch(_) { | |
9712 // Fall through | |
9713 } | |
9714 } | |
9715 throw jsonDecoder.mismatch(jsonPath, "FoldingKind", json); | |
9716 } | |
9717 | |
9718 @override | |
9719 String toString() => "FoldingKind.$name"; | |
9720 | |
9721 String toJson() => name; | |
9722 } | |
9723 | |
9724 /** | |
9725 * FoldingRegion | |
9726 * | |
9727 * { | |
9728 * "kind": FoldingKind | |
9729 * "offset": int | |
9730 * "length": int | |
9731 * } | |
9732 */ | |
9733 class FoldingRegion implements HasToJson { | |
9734 FoldingKind _kind; | |
9735 | |
9736 int _offset; | |
9737 | |
9738 int _length; | |
9739 | |
9740 /** | |
9741 * The kind of the region. | |
9742 */ | |
9743 FoldingKind get kind => _kind; | |
9744 | |
9745 /** | |
9746 * The kind of the region. | |
9747 */ | |
9748 void set kind(FoldingKind value) { | |
9749 assert(value != null); | |
9750 this._kind = value; | |
9751 } | |
9752 | |
9753 /** | |
9754 * The offset of the region to be folded. | |
9755 */ | |
9756 int get offset => _offset; | |
9757 | |
9758 /** | |
9759 * The offset of the region to be folded. | |
9760 */ | |
9761 void set offset(int value) { | |
9762 assert(value != null); | |
9763 this._offset = value; | |
9764 } | |
9765 | |
9766 /** | |
9767 * The length of the region to be folded. | |
9768 */ | |
9769 int get length => _length; | |
9770 | |
9771 /** | |
9772 * The length of the region to be folded. | |
9773 */ | |
9774 void set length(int value) { | |
9775 assert(value != null); | |
9776 this._length = value; | |
9777 } | |
9778 | |
9779 FoldingRegion(FoldingKind kind, int offset, int length) { | |
9780 this.kind = kind; | |
9781 this.offset = offset; | |
9782 this.length = length; | |
9783 } | |
9784 | |
9785 factory FoldingRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Objec
t json) { | |
9786 if (json == null) { | |
9787 json = {}; | |
9788 } | |
9789 if (json is Map) { | |
9790 FoldingKind kind; | |
9791 if (json.containsKey("kind")) { | |
9792 kind = new FoldingKind.fromJson(jsonDecoder, jsonPath + ".kind", json["k
ind"]); | |
9793 } else { | |
9794 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
9795 } | |
9796 int offset; | |
9797 if (json.containsKey("offset")) { | |
9798 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
9799 } else { | |
9800 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
9801 } | |
9802 int length; | |
9803 if (json.containsKey("length")) { | |
9804 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
9805 } else { | |
9806 throw jsonDecoder.missingKey(jsonPath, "length"); | |
9807 } | |
9808 return new FoldingRegion(kind, offset, length); | |
9809 } else { | |
9810 throw jsonDecoder.mismatch(jsonPath, "FoldingRegion", json); | |
9811 } | |
9812 } | |
9813 | |
9814 Map<String, dynamic> toJson() { | |
9815 Map<String, dynamic> result = {}; | |
9816 result["kind"] = kind.toJson(); | |
9817 result["offset"] = offset; | |
9818 result["length"] = length; | |
9819 return result; | |
9820 } | |
9821 | |
9822 @override | |
9823 String toString() => JSON.encode(toJson()); | |
9824 | |
9825 @override | |
9826 bool operator==(other) { | |
9827 if (other is FoldingRegion) { | |
9828 return kind == other.kind && | |
9829 offset == other.offset && | |
9830 length == other.length; | |
9831 } | |
9832 return false; | |
9833 } | |
9834 | |
9835 @override | |
9836 int get hashCode { | |
9837 int hash = 0; | |
9838 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
9839 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
9840 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
9841 return _JenkinsSmiHash.finish(hash); | |
9842 } | |
9843 } | |
9844 | |
9845 /** | |
9846 * GeneralAnalysisService | |
9847 * | |
9848 * enum { | |
9849 * ANALYZED_FILES | |
9850 * } | |
9851 */ | |
9852 class GeneralAnalysisService implements Enum { | |
9853 static const ANALYZED_FILES = const GeneralAnalysisService._("ANALYZED_FILES")
; | |
9854 | |
9855 /** | |
9856 * A list containing all of the enum values that are defined. | |
9857 */ | |
9858 static const List<GeneralAnalysisService> VALUES = const <GeneralAnalysisServi
ce>[ANALYZED_FILES]; | |
9859 | |
9860 final String name; | |
9861 | |
9862 const GeneralAnalysisService._(this.name); | |
9863 | |
9864 factory GeneralAnalysisService(String name) { | |
9865 switch (name) { | |
9866 case "ANALYZED_FILES": | |
9867 return ANALYZED_FILES; | |
9868 } | |
9869 throw new Exception('Illegal enum value: $name'); | |
9870 } | |
9871 | |
9872 factory GeneralAnalysisService.fromJson(JsonDecoder jsonDecoder, String jsonPa
th, Object json) { | |
9873 if (json is String) { | |
9874 try { | |
9875 return new GeneralAnalysisService(json); | |
9876 } catch(_) { | |
9877 // Fall through | |
9878 } | |
9879 } | |
9880 throw jsonDecoder.mismatch(jsonPath, "GeneralAnalysisService", json); | |
9881 } | |
9882 | |
9883 @override | |
9884 String toString() => "GeneralAnalysisService.$name"; | |
9885 | |
9886 String toJson() => name; | |
9887 } | |
9888 | |
9889 /** | |
9890 * HighlightRegion | |
9891 * | |
9892 * { | |
9893 * "type": HighlightRegionType | |
9894 * "offset": int | |
9895 * "length": int | |
9896 * } | |
9897 */ | |
9898 class HighlightRegion implements HasToJson { | |
9899 HighlightRegionType _type; | |
9900 | |
9901 int _offset; | |
9902 | |
9903 int _length; | |
9904 | |
9905 /** | |
9906 * The type of highlight associated with the region. | |
9907 */ | |
9908 HighlightRegionType get type => _type; | |
9909 | |
9910 /** | |
9911 * The type of highlight associated with the region. | |
9912 */ | |
9913 void set type(HighlightRegionType value) { | |
9914 assert(value != null); | |
9915 this._type = value; | |
9916 } | |
9917 | |
9918 /** | |
9919 * The offset of the region to be highlighted. | |
9920 */ | |
9921 int get offset => _offset; | |
9922 | |
9923 /** | |
9924 * The offset of the region to be highlighted. | |
9925 */ | |
9926 void set offset(int value) { | |
9927 assert(value != null); | |
9928 this._offset = value; | |
9929 } | |
9930 | |
9931 /** | |
9932 * The length of the region to be highlighted. | |
9933 */ | |
9934 int get length => _length; | |
9935 | |
9936 /** | |
9937 * The length of the region to be highlighted. | |
9938 */ | |
9939 void set length(int value) { | |
9940 assert(value != null); | |
9941 this._length = value; | |
9942 } | |
9943 | |
9944 HighlightRegion(HighlightRegionType type, int offset, int length) { | |
9945 this.type = type; | |
9946 this.offset = offset; | |
9947 this.length = length; | |
9948 } | |
9949 | |
9950 factory HighlightRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obj
ect json) { | |
9951 if (json == null) { | |
9952 json = {}; | |
9953 } | |
9954 if (json is Map) { | |
9955 HighlightRegionType type; | |
9956 if (json.containsKey("type")) { | |
9957 type = new HighlightRegionType.fromJson(jsonDecoder, jsonPath + ".type",
json["type"]); | |
9958 } else { | |
9959 throw jsonDecoder.missingKey(jsonPath, "type"); | |
9960 } | |
9961 int offset; | |
9962 if (json.containsKey("offset")) { | |
9963 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
9964 } else { | |
9965 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
9966 } | |
9967 int length; | |
9968 if (json.containsKey("length")) { | |
9969 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
9970 } else { | |
9971 throw jsonDecoder.missingKey(jsonPath, "length"); | |
9972 } | |
9973 return new HighlightRegion(type, offset, length); | |
9974 } else { | |
9975 throw jsonDecoder.mismatch(jsonPath, "HighlightRegion", json); | |
9976 } | |
9977 } | |
9978 | |
9979 Map<String, dynamic> toJson() { | |
9980 Map<String, dynamic> result = {}; | |
9981 result["type"] = type.toJson(); | |
9982 result["offset"] = offset; | |
9983 result["length"] = length; | |
9984 return result; | |
9985 } | |
9986 | |
9987 @override | |
9988 String toString() => JSON.encode(toJson()); | |
9989 | |
9990 @override | |
9991 bool operator==(other) { | |
9992 if (other is HighlightRegion) { | |
9993 return type == other.type && | |
9994 offset == other.offset && | |
9995 length == other.length; | |
9996 } | |
9997 return false; | |
9998 } | |
9999 | |
10000 @override | |
10001 int get hashCode { | |
10002 int hash = 0; | |
10003 hash = _JenkinsSmiHash.combine(hash, type.hashCode); | |
10004 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
10005 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
10006 return _JenkinsSmiHash.finish(hash); | |
10007 } | |
10008 } | |
10009 | |
10010 /** | |
10011 * HighlightRegionType | |
10012 * | |
10013 * enum { | |
10014 * ANNOTATION | |
10015 * BUILT_IN | |
10016 * CLASS | |
10017 * COMMENT_BLOCK | |
10018 * COMMENT_DOCUMENTATION | |
10019 * COMMENT_END_OF_LINE | |
10020 * CONSTRUCTOR | |
10021 * DIRECTIVE | |
10022 * DYNAMIC_TYPE | |
10023 * DYNAMIC_LOCAL_VARIABLE_DECLARATION | |
10024 * DYNAMIC_LOCAL_VARIABLE_REFERENCE | |
10025 * DYNAMIC_PARAMETER_DECLARATION | |
10026 * DYNAMIC_PARAMETER_REFERENCE | |
10027 * ENUM | |
10028 * ENUM_CONSTANT | |
10029 * FIELD | |
10030 * FIELD_STATIC | |
10031 * FUNCTION | |
10032 * FUNCTION_DECLARATION | |
10033 * FUNCTION_TYPE_ALIAS | |
10034 * GETTER_DECLARATION | |
10035 * IDENTIFIER_DEFAULT | |
10036 * IMPORT_PREFIX | |
10037 * INSTANCE_FIELD_DECLARATION | |
10038 * INSTANCE_FIELD_REFERENCE | |
10039 * INSTANCE_GETTER_DECLARATION | |
10040 * INSTANCE_GETTER_REFERENCE | |
10041 * INSTANCE_METHOD_DECLARATION | |
10042 * INSTANCE_METHOD_REFERENCE | |
10043 * INSTANCE_SETTER_DECLARATION | |
10044 * INSTANCE_SETTER_REFERENCE | |
10045 * INVALID_STRING_ESCAPE | |
10046 * KEYWORD | |
10047 * LABEL | |
10048 * LIBRARY_NAME | |
10049 * LITERAL_BOOLEAN | |
10050 * LITERAL_DOUBLE | |
10051 * LITERAL_INTEGER | |
10052 * LITERAL_LIST | |
10053 * LITERAL_MAP | |
10054 * LITERAL_STRING | |
10055 * LOCAL_FUNCTION_DECLARATION | |
10056 * LOCAL_FUNCTION_REFERENCE | |
10057 * LOCAL_VARIABLE | |
10058 * LOCAL_VARIABLE_DECLARATION | |
10059 * LOCAL_VARIABLE_REFERENCE | |
10060 * METHOD | |
10061 * METHOD_DECLARATION | |
10062 * METHOD_DECLARATION_STATIC | |
10063 * METHOD_STATIC | |
10064 * PARAMETER | |
10065 * SETTER_DECLARATION | |
10066 * TOP_LEVEL_VARIABLE | |
10067 * PARAMETER_DECLARATION | |
10068 * PARAMETER_REFERENCE | |
10069 * STATIC_FIELD_DECLARATION | |
10070 * STATIC_GETTER_DECLARATION | |
10071 * STATIC_GETTER_REFERENCE | |
10072 * STATIC_METHOD_DECLARATION | |
10073 * STATIC_METHOD_REFERENCE | |
10074 * STATIC_SETTER_DECLARATION | |
10075 * STATIC_SETTER_REFERENCE | |
10076 * TOP_LEVEL_FUNCTION_DECLARATION | |
10077 * TOP_LEVEL_FUNCTION_REFERENCE | |
10078 * TOP_LEVEL_GETTER_DECLARATION | |
10079 * TOP_LEVEL_GETTER_REFERENCE | |
10080 * TOP_LEVEL_SETTER_DECLARATION | |
10081 * TOP_LEVEL_SETTER_REFERENCE | |
10082 * TOP_LEVEL_VARIABLE_DECLARATION | |
10083 * TYPE_NAME_DYNAMIC | |
10084 * TYPE_PARAMETER | |
10085 * UNRESOLVED_INSTANCE_MEMBER_REFERENCE | |
10086 * VALID_STRING_ESCAPE | |
10087 * } | |
10088 */ | |
10089 class HighlightRegionType implements Enum { | |
10090 static const ANNOTATION = const HighlightRegionType._("ANNOTATION"); | |
10091 | |
10092 static const BUILT_IN = const HighlightRegionType._("BUILT_IN"); | |
10093 | |
10094 static const CLASS = const HighlightRegionType._("CLASS"); | |
10095 | |
10096 static const COMMENT_BLOCK = const HighlightRegionType._("COMMENT_BLOCK"); | |
10097 | |
10098 static const COMMENT_DOCUMENTATION = const HighlightRegionType._("COMMENT_DOCU
MENTATION"); | |
10099 | |
10100 static const COMMENT_END_OF_LINE = const HighlightRegionType._("COMMENT_END_OF
_LINE"); | |
10101 | |
10102 static const CONSTRUCTOR = const HighlightRegionType._("CONSTRUCTOR"); | |
10103 | |
10104 static const DIRECTIVE = const HighlightRegionType._("DIRECTIVE"); | |
10105 | |
10106 /** | |
10107 * Only for version 1 of highlight. | |
10108 */ | |
10109 static const DYNAMIC_TYPE = const HighlightRegionType._("DYNAMIC_TYPE"); | |
10110 | |
10111 /** | |
10112 * Only for version 2 of highlight. | |
10113 */ | |
10114 static const DYNAMIC_LOCAL_VARIABLE_DECLARATION = const HighlightRegionType._(
"DYNAMIC_LOCAL_VARIABLE_DECLARATION"); | |
10115 | |
10116 /** | |
10117 * Only for version 2 of highlight. | |
10118 */ | |
10119 static const DYNAMIC_LOCAL_VARIABLE_REFERENCE = const HighlightRegionType._("D
YNAMIC_LOCAL_VARIABLE_REFERENCE"); | |
10120 | |
10121 /** | |
10122 * Only for version 2 of highlight. | |
10123 */ | |
10124 static const DYNAMIC_PARAMETER_DECLARATION = const HighlightRegionType._("DYNA
MIC_PARAMETER_DECLARATION"); | |
10125 | |
10126 /** | |
10127 * Only for version 2 of highlight. | |
10128 */ | |
10129 static const DYNAMIC_PARAMETER_REFERENCE = const HighlightRegionType._("DYNAMI
C_PARAMETER_REFERENCE"); | |
10130 | |
10131 static const ENUM = const HighlightRegionType._("ENUM"); | |
10132 | |
10133 static const ENUM_CONSTANT = const HighlightRegionType._("ENUM_CONSTANT"); | |
10134 | |
10135 /** | |
10136 * Only for version 1 of highlight. | |
10137 */ | |
10138 static const FIELD = const HighlightRegionType._("FIELD"); | |
10139 | |
10140 /** | |
10141 * Only for version 1 of highlight. | |
10142 */ | |
10143 static const FIELD_STATIC = const HighlightRegionType._("FIELD_STATIC"); | |
10144 | |
10145 /** | |
10146 * Only for version 1 of highlight. | |
10147 */ | |
10148 static const FUNCTION = const HighlightRegionType._("FUNCTION"); | |
10149 | |
10150 /** | |
10151 * Only for version 1 of highlight. | |
10152 */ | |
10153 static const FUNCTION_DECLARATION = const HighlightRegionType._("FUNCTION_DECL
ARATION"); | |
10154 | |
10155 static const FUNCTION_TYPE_ALIAS = const HighlightRegionType._("FUNCTION_TYPE_
ALIAS"); | |
10156 | |
10157 /** | |
10158 * Only for version 1 of highlight. | |
10159 */ | |
10160 static const GETTER_DECLARATION = const HighlightRegionType._("GETTER_DECLARAT
ION"); | |
10161 | |
10162 static const IDENTIFIER_DEFAULT = const HighlightRegionType._("IDENTIFIER_DEFA
ULT"); | |
10163 | |
10164 static const IMPORT_PREFIX = const HighlightRegionType._("IMPORT_PREFIX"); | |
10165 | |
10166 /** | |
10167 * Only for version 2 of highlight. | |
10168 */ | |
10169 static const INSTANCE_FIELD_DECLARATION = const HighlightRegionType._("INSTANC
E_FIELD_DECLARATION"); | |
10170 | |
10171 /** | |
10172 * Only for version 2 of highlight. | |
10173 */ | |
10174 static const INSTANCE_FIELD_REFERENCE = const HighlightRegionType._("INSTANCE_
FIELD_REFERENCE"); | |
10175 | |
10176 /** | |
10177 * Only for version 2 of highlight. | |
10178 */ | |
10179 static const INSTANCE_GETTER_DECLARATION = const HighlightRegionType._("INSTAN
CE_GETTER_DECLARATION"); | |
10180 | |
10181 /** | |
10182 * Only for version 2 of highlight. | |
10183 */ | |
10184 static const INSTANCE_GETTER_REFERENCE = const HighlightRegionType._("INSTANCE
_GETTER_REFERENCE"); | |
10185 | |
10186 /** | |
10187 * Only for version 2 of highlight. | |
10188 */ | |
10189 static const INSTANCE_METHOD_DECLARATION = const HighlightRegionType._("INSTAN
CE_METHOD_DECLARATION"); | |
10190 | |
10191 /** | |
10192 * Only for version 2 of highlight. | |
10193 */ | |
10194 static const INSTANCE_METHOD_REFERENCE = const HighlightRegionType._("INSTANCE
_METHOD_REFERENCE"); | |
10195 | |
10196 /** | |
10197 * Only for version 2 of highlight. | |
10198 */ | |
10199 static const INSTANCE_SETTER_DECLARATION = const HighlightRegionType._("INSTAN
CE_SETTER_DECLARATION"); | |
10200 | |
10201 /** | |
10202 * Only for version 2 of highlight. | |
10203 */ | |
10204 static const INSTANCE_SETTER_REFERENCE = const HighlightRegionType._("INSTANCE
_SETTER_REFERENCE"); | |
10205 | |
10206 /** | |
10207 * Only for version 2 of highlight. | |
10208 */ | |
10209 static const INVALID_STRING_ESCAPE = const HighlightRegionType._("INVALID_STRI
NG_ESCAPE"); | |
10210 | |
10211 static const KEYWORD = const HighlightRegionType._("KEYWORD"); | |
10212 | |
10213 static const LABEL = const HighlightRegionType._("LABEL"); | |
10214 | |
10215 /** | |
10216 * Only for version 2 of highlight. | |
10217 */ | |
10218 static const LIBRARY_NAME = const HighlightRegionType._("LIBRARY_NAME"); | |
10219 | |
10220 static const LITERAL_BOOLEAN = const HighlightRegionType._("LITERAL_BOOLEAN"); | |
10221 | |
10222 static const LITERAL_DOUBLE = const HighlightRegionType._("LITERAL_DOUBLE"); | |
10223 | |
10224 static const LITERAL_INTEGER = const HighlightRegionType._("LITERAL_INTEGER"); | |
10225 | |
10226 static const LITERAL_LIST = const HighlightRegionType._("LITERAL_LIST"); | |
10227 | |
10228 static const LITERAL_MAP = const HighlightRegionType._("LITERAL_MAP"); | |
10229 | |
10230 static const LITERAL_STRING = const HighlightRegionType._("LITERAL_STRING"); | |
10231 | |
10232 /** | |
10233 * Only for version 2 of highlight. | |
10234 */ | |
10235 static const LOCAL_FUNCTION_DECLARATION = const HighlightRegionType._("LOCAL_F
UNCTION_DECLARATION"); | |
10236 | |
10237 /** | |
10238 * Only for version 2 of highlight. | |
10239 */ | |
10240 static const LOCAL_FUNCTION_REFERENCE = const HighlightRegionType._("LOCAL_FUN
CTION_REFERENCE"); | |
10241 | |
10242 /** | |
10243 * Only for version 1 of highlight. | |
10244 */ | |
10245 static const LOCAL_VARIABLE = const HighlightRegionType._("LOCAL_VARIABLE"); | |
10246 | |
10247 static const LOCAL_VARIABLE_DECLARATION = const HighlightRegionType._("LOCAL_V
ARIABLE_DECLARATION"); | |
10248 | |
10249 /** | |
10250 * Only for version 2 of highlight. | |
10251 */ | |
10252 static const LOCAL_VARIABLE_REFERENCE = const HighlightRegionType._("LOCAL_VAR
IABLE_REFERENCE"); | |
10253 | |
10254 /** | |
10255 * Only for version 1 of highlight. | |
10256 */ | |
10257 static const METHOD = const HighlightRegionType._("METHOD"); | |
10258 | |
10259 /** | |
10260 * Only for version 1 of highlight. | |
10261 */ | |
10262 static const METHOD_DECLARATION = const HighlightRegionType._("METHOD_DECLARAT
ION"); | |
10263 | |
10264 /** | |
10265 * Only for version 1 of highlight. | |
10266 */ | |
10267 static const METHOD_DECLARATION_STATIC = const HighlightRegionType._("METHOD_D
ECLARATION_STATIC"); | |
10268 | |
10269 /** | |
10270 * Only for version 1 of highlight. | |
10271 */ | |
10272 static const METHOD_STATIC = const HighlightRegionType._("METHOD_STATIC"); | |
10273 | |
10274 /** | |
10275 * Only for version 1 of highlight. | |
10276 */ | |
10277 static const PARAMETER = const HighlightRegionType._("PARAMETER"); | |
10278 | |
10279 /** | |
10280 * Only for version 1 of highlight. | |
10281 */ | |
10282 static const SETTER_DECLARATION = const HighlightRegionType._("SETTER_DECLARAT
ION"); | |
10283 | |
10284 /** | |
10285 * Only for version 1 of highlight. | |
10286 */ | |
10287 static const TOP_LEVEL_VARIABLE = const HighlightRegionType._("TOP_LEVEL_VARIA
BLE"); | |
10288 | |
10289 /** | |
10290 * Only for version 2 of highlight. | |
10291 */ | |
10292 static const PARAMETER_DECLARATION = const HighlightRegionType._("PARAMETER_DE
CLARATION"); | |
10293 | |
10294 /** | |
10295 * Only for version 2 of highlight. | |
10296 */ | |
10297 static const PARAMETER_REFERENCE = const HighlightRegionType._("PARAMETER_REFE
RENCE"); | |
10298 | |
10299 /** | |
10300 * Only for version 2 of highlight. | |
10301 */ | |
10302 static const STATIC_FIELD_DECLARATION = const HighlightRegionType._("STATIC_FI
ELD_DECLARATION"); | |
10303 | |
10304 /** | |
10305 * Only for version 2 of highlight. | |
10306 */ | |
10307 static const STATIC_GETTER_DECLARATION = const HighlightRegionType._("STATIC_G
ETTER_DECLARATION"); | |
10308 | |
10309 /** | |
10310 * Only for version 2 of highlight. | |
10311 */ | |
10312 static const STATIC_GETTER_REFERENCE = const HighlightRegionType._("STATIC_GET
TER_REFERENCE"); | |
10313 | |
10314 /** | |
10315 * Only for version 2 of highlight. | |
10316 */ | |
10317 static const STATIC_METHOD_DECLARATION = const HighlightRegionType._("STATIC_M
ETHOD_DECLARATION"); | |
10318 | |
10319 /** | |
10320 * Only for version 2 of highlight. | |
10321 */ | |
10322 static const STATIC_METHOD_REFERENCE = const HighlightRegionType._("STATIC_MET
HOD_REFERENCE"); | |
10323 | |
10324 /** | |
10325 * Only for version 2 of highlight. | |
10326 */ | |
10327 static const STATIC_SETTER_DECLARATION = const HighlightRegionType._("STATIC_S
ETTER_DECLARATION"); | |
10328 | |
10329 /** | |
10330 * Only for version 2 of highlight. | |
10331 */ | |
10332 static const STATIC_SETTER_REFERENCE = const HighlightRegionType._("STATIC_SET
TER_REFERENCE"); | |
10333 | |
10334 /** | |
10335 * Only for version 2 of highlight. | |
10336 */ | |
10337 static const TOP_LEVEL_FUNCTION_DECLARATION = const HighlightRegionType._("TOP
_LEVEL_FUNCTION_DECLARATION"); | |
10338 | |
10339 /** | |
10340 * Only for version 2 of highlight. | |
10341 */ | |
10342 static const TOP_LEVEL_FUNCTION_REFERENCE = const HighlightRegionType._("TOP_L
EVEL_FUNCTION_REFERENCE"); | |
10343 | |
10344 /** | |
10345 * Only for version 2 of highlight. | |
10346 */ | |
10347 static const TOP_LEVEL_GETTER_DECLARATION = const HighlightRegionType._("TOP_L
EVEL_GETTER_DECLARATION"); | |
10348 | |
10349 /** | |
10350 * Only for version 2 of highlight. | |
10351 */ | |
10352 static const TOP_LEVEL_GETTER_REFERENCE = const HighlightRegionType._("TOP_LEV
EL_GETTER_REFERENCE"); | |
10353 | |
10354 /** | |
10355 * Only for version 2 of highlight. | |
10356 */ | |
10357 static const TOP_LEVEL_SETTER_DECLARATION = const HighlightRegionType._("TOP_L
EVEL_SETTER_DECLARATION"); | |
10358 | |
10359 /** | |
10360 * Only for version 2 of highlight. | |
10361 */ | |
10362 static const TOP_LEVEL_SETTER_REFERENCE = const HighlightRegionType._("TOP_LEV
EL_SETTER_REFERENCE"); | |
10363 | |
10364 /** | |
10365 * Only for version 2 of highlight. | |
10366 */ | |
10367 static const TOP_LEVEL_VARIABLE_DECLARATION = const HighlightRegionType._("TOP
_LEVEL_VARIABLE_DECLARATION"); | |
10368 | |
10369 static const TYPE_NAME_DYNAMIC = const HighlightRegionType._("TYPE_NAME_DYNAMI
C"); | |
10370 | |
10371 static const TYPE_PARAMETER = const HighlightRegionType._("TYPE_PARAMETER"); | |
10372 | |
10373 /** | |
10374 * Only for version 2 of highlight. | |
10375 */ | |
10376 static const UNRESOLVED_INSTANCE_MEMBER_REFERENCE = const HighlightRegionType.
_("UNRESOLVED_INSTANCE_MEMBER_REFERENCE"); | |
10377 | |
10378 /** | |
10379 * Only for version 2 of highlight. | |
10380 */ | |
10381 static const VALID_STRING_ESCAPE = const HighlightRegionType._("VALID_STRING_E
SCAPE"); | |
10382 | |
10383 /** | |
10384 * A list containing all of the enum values that are defined. | |
10385 */ | |
10386 static const List<HighlightRegionType> VALUES = const <HighlightRegionType>[AN
NOTATION, BUILT_IN, CLASS, COMMENT_BLOCK, COMMENT_DOCUMENTATION, COMMENT_END_OF_
LINE, CONSTRUCTOR, DIRECTIVE, DYNAMIC_TYPE, DYNAMIC_LOCAL_VARIABLE_DECLARATION,
DYNAMIC_LOCAL_VARIABLE_REFERENCE, DYNAMIC_PARAMETER_DECLARATION, DYNAMIC_PARAMET
ER_REFERENCE, ENUM, ENUM_CONSTANT, FIELD, FIELD_STATIC, FUNCTION, FUNCTION_DECLA
RATION, FUNCTION_TYPE_ALIAS, GETTER_DECLARATION, IDENTIFIER_DEFAULT, IMPORT_PREF
IX, INSTANCE_FIELD_DECLARATION, INSTANCE_FIELD_REFERENCE, INSTANCE_GETTER_DECLAR
ATION, INSTANCE_GETTER_REFERENCE, INSTANCE_METHOD_DECLARATION, INSTANCE_METHOD_R
EFERENCE, INSTANCE_SETTER_DECLARATION, INSTANCE_SETTER_REFERENCE, INVALID_STRING
_ESCAPE, KEYWORD, LABEL, LIBRARY_NAME, LITERAL_BOOLEAN, LITERAL_DOUBLE, LITERAL_
INTEGER, LITERAL_LIST, LITERAL_MAP, LITERAL_STRING, LOCAL_FUNCTION_DECLARATION,
LOCAL_FUNCTION_REFERENCE, LOCAL_VARIABLE, LOCAL_VARIABLE_DECLARATION, LOCAL_VARI
ABLE_REFERENCE, METHOD, METHOD_DECLARATION, METHOD_DECLARATION_STATIC, METHOD_ST
ATIC, PARAMETER, SETTER_DECLARATION, TOP_LEVEL_VARIABLE, PARAMETER_DECLARATION,
PARAMETER_REFERENCE, STATIC_FIELD_DECLARATION, STATIC_GETTER_DECLARATION, STATIC
_GETTER_REFERENCE, STATIC_METHOD_DECLARATION, STATIC_METHOD_REFERENCE, STATIC_SE
TTER_DECLARATION, STATIC_SETTER_REFERENCE, TOP_LEVEL_FUNCTION_DECLARATION, TOP_L
EVEL_FUNCTION_REFERENCE, TOP_LEVEL_GETTER_DECLARATION, TOP_LEVEL_GETTER_REFERENC
E, TOP_LEVEL_SETTER_DECLARATION, TOP_LEVEL_SETTER_REFERENCE, TOP_LEVEL_VARIABLE_
DECLARATION, TYPE_NAME_DYNAMIC, TYPE_PARAMETER, UNRESOLVED_INSTANCE_MEMBER_REFER
ENCE, VALID_STRING_ESCAPE]; | |
10387 | |
10388 final String name; | |
10389 | |
10390 const HighlightRegionType._(this.name); | |
10391 | |
10392 factory HighlightRegionType(String name) { | |
10393 switch (name) { | |
10394 case "ANNOTATION": | |
10395 return ANNOTATION; | |
10396 case "BUILT_IN": | |
10397 return BUILT_IN; | |
10398 case "CLASS": | |
10399 return CLASS; | |
10400 case "COMMENT_BLOCK": | |
10401 return COMMENT_BLOCK; | |
10402 case "COMMENT_DOCUMENTATION": | |
10403 return COMMENT_DOCUMENTATION; | |
10404 case "COMMENT_END_OF_LINE": | |
10405 return COMMENT_END_OF_LINE; | |
10406 case "CONSTRUCTOR": | |
10407 return CONSTRUCTOR; | |
10408 case "DIRECTIVE": | |
10409 return DIRECTIVE; | |
10410 case "DYNAMIC_TYPE": | |
10411 return DYNAMIC_TYPE; | |
10412 case "DYNAMIC_LOCAL_VARIABLE_DECLARATION": | |
10413 return DYNAMIC_LOCAL_VARIABLE_DECLARATION; | |
10414 case "DYNAMIC_LOCAL_VARIABLE_REFERENCE": | |
10415 return DYNAMIC_LOCAL_VARIABLE_REFERENCE; | |
10416 case "DYNAMIC_PARAMETER_DECLARATION": | |
10417 return DYNAMIC_PARAMETER_DECLARATION; | |
10418 case "DYNAMIC_PARAMETER_REFERENCE": | |
10419 return DYNAMIC_PARAMETER_REFERENCE; | |
10420 case "ENUM": | |
10421 return ENUM; | |
10422 case "ENUM_CONSTANT": | |
10423 return ENUM_CONSTANT; | |
10424 case "FIELD": | |
10425 return FIELD; | |
10426 case "FIELD_STATIC": | |
10427 return FIELD_STATIC; | |
10428 case "FUNCTION": | |
10429 return FUNCTION; | |
10430 case "FUNCTION_DECLARATION": | |
10431 return FUNCTION_DECLARATION; | |
10432 case "FUNCTION_TYPE_ALIAS": | |
10433 return FUNCTION_TYPE_ALIAS; | |
10434 case "GETTER_DECLARATION": | |
10435 return GETTER_DECLARATION; | |
10436 case "IDENTIFIER_DEFAULT": | |
10437 return IDENTIFIER_DEFAULT; | |
10438 case "IMPORT_PREFIX": | |
10439 return IMPORT_PREFIX; | |
10440 case "INSTANCE_FIELD_DECLARATION": | |
10441 return INSTANCE_FIELD_DECLARATION; | |
10442 case "INSTANCE_FIELD_REFERENCE": | |
10443 return INSTANCE_FIELD_REFERENCE; | |
10444 case "INSTANCE_GETTER_DECLARATION": | |
10445 return INSTANCE_GETTER_DECLARATION; | |
10446 case "INSTANCE_GETTER_REFERENCE": | |
10447 return INSTANCE_GETTER_REFERENCE; | |
10448 case "INSTANCE_METHOD_DECLARATION": | |
10449 return INSTANCE_METHOD_DECLARATION; | |
10450 case "INSTANCE_METHOD_REFERENCE": | |
10451 return INSTANCE_METHOD_REFERENCE; | |
10452 case "INSTANCE_SETTER_DECLARATION": | |
10453 return INSTANCE_SETTER_DECLARATION; | |
10454 case "INSTANCE_SETTER_REFERENCE": | |
10455 return INSTANCE_SETTER_REFERENCE; | |
10456 case "INVALID_STRING_ESCAPE": | |
10457 return INVALID_STRING_ESCAPE; | |
10458 case "KEYWORD": | |
10459 return KEYWORD; | |
10460 case "LABEL": | |
10461 return LABEL; | |
10462 case "LIBRARY_NAME": | |
10463 return LIBRARY_NAME; | |
10464 case "LITERAL_BOOLEAN": | |
10465 return LITERAL_BOOLEAN; | |
10466 case "LITERAL_DOUBLE": | |
10467 return LITERAL_DOUBLE; | |
10468 case "LITERAL_INTEGER": | |
10469 return LITERAL_INTEGER; | |
10470 case "LITERAL_LIST": | |
10471 return LITERAL_LIST; | |
10472 case "LITERAL_MAP": | |
10473 return LITERAL_MAP; | |
10474 case "LITERAL_STRING": | |
10475 return LITERAL_STRING; | |
10476 case "LOCAL_FUNCTION_DECLARATION": | |
10477 return LOCAL_FUNCTION_DECLARATION; | |
10478 case "LOCAL_FUNCTION_REFERENCE": | |
10479 return LOCAL_FUNCTION_REFERENCE; | |
10480 case "LOCAL_VARIABLE": | |
10481 return LOCAL_VARIABLE; | |
10482 case "LOCAL_VARIABLE_DECLARATION": | |
10483 return LOCAL_VARIABLE_DECLARATION; | |
10484 case "LOCAL_VARIABLE_REFERENCE": | |
10485 return LOCAL_VARIABLE_REFERENCE; | |
10486 case "METHOD": | |
10487 return METHOD; | |
10488 case "METHOD_DECLARATION": | |
10489 return METHOD_DECLARATION; | |
10490 case "METHOD_DECLARATION_STATIC": | |
10491 return METHOD_DECLARATION_STATIC; | |
10492 case "METHOD_STATIC": | |
10493 return METHOD_STATIC; | |
10494 case "PARAMETER": | |
10495 return PARAMETER; | |
10496 case "SETTER_DECLARATION": | |
10497 return SETTER_DECLARATION; | |
10498 case "TOP_LEVEL_VARIABLE": | |
10499 return TOP_LEVEL_VARIABLE; | |
10500 case "PARAMETER_DECLARATION": | |
10501 return PARAMETER_DECLARATION; | |
10502 case "PARAMETER_REFERENCE": | |
10503 return PARAMETER_REFERENCE; | |
10504 case "STATIC_FIELD_DECLARATION": | |
10505 return STATIC_FIELD_DECLARATION; | |
10506 case "STATIC_GETTER_DECLARATION": | |
10507 return STATIC_GETTER_DECLARATION; | |
10508 case "STATIC_GETTER_REFERENCE": | |
10509 return STATIC_GETTER_REFERENCE; | |
10510 case "STATIC_METHOD_DECLARATION": | |
10511 return STATIC_METHOD_DECLARATION; | |
10512 case "STATIC_METHOD_REFERENCE": | |
10513 return STATIC_METHOD_REFERENCE; | |
10514 case "STATIC_SETTER_DECLARATION": | |
10515 return STATIC_SETTER_DECLARATION; | |
10516 case "STATIC_SETTER_REFERENCE": | |
10517 return STATIC_SETTER_REFERENCE; | |
10518 case "TOP_LEVEL_FUNCTION_DECLARATION": | |
10519 return TOP_LEVEL_FUNCTION_DECLARATION; | |
10520 case "TOP_LEVEL_FUNCTION_REFERENCE": | |
10521 return TOP_LEVEL_FUNCTION_REFERENCE; | |
10522 case "TOP_LEVEL_GETTER_DECLARATION": | |
10523 return TOP_LEVEL_GETTER_DECLARATION; | |
10524 case "TOP_LEVEL_GETTER_REFERENCE": | |
10525 return TOP_LEVEL_GETTER_REFERENCE; | |
10526 case "TOP_LEVEL_SETTER_DECLARATION": | |
10527 return TOP_LEVEL_SETTER_DECLARATION; | |
10528 case "TOP_LEVEL_SETTER_REFERENCE": | |
10529 return TOP_LEVEL_SETTER_REFERENCE; | |
10530 case "TOP_LEVEL_VARIABLE_DECLARATION": | |
10531 return TOP_LEVEL_VARIABLE_DECLARATION; | |
10532 case "TYPE_NAME_DYNAMIC": | |
10533 return TYPE_NAME_DYNAMIC; | |
10534 case "TYPE_PARAMETER": | |
10535 return TYPE_PARAMETER; | |
10536 case "UNRESOLVED_INSTANCE_MEMBER_REFERENCE": | |
10537 return UNRESOLVED_INSTANCE_MEMBER_REFERENCE; | |
10538 case "VALID_STRING_ESCAPE": | |
10539 return VALID_STRING_ESCAPE; | |
10540 } | |
10541 throw new Exception('Illegal enum value: $name'); | |
10542 } | |
10543 | |
10544 factory HighlightRegionType.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json) { | |
10545 if (json is String) { | |
10546 try { | |
10547 return new HighlightRegionType(json); | |
10548 } catch(_) { | |
10549 // Fall through | |
10550 } | |
10551 } | |
10552 throw jsonDecoder.mismatch(jsonPath, "HighlightRegionType", json); | |
10553 } | |
10554 | |
10555 @override | |
10556 String toString() => "HighlightRegionType.$name"; | |
10557 | |
10558 String toJson() => name; | |
10559 } | |
10560 | |
10561 /** | |
10562 * HoverInformation | |
10563 * | |
10564 * { | |
10565 * "offset": int | |
10566 * "length": int | |
10567 * "containingLibraryPath": optional String | |
10568 * "containingLibraryName": optional String | |
10569 * "containingClassDescription": optional String | |
10570 * "dartdoc": optional String | |
10571 * "elementDescription": optional String | |
10572 * "elementKind": optional String | |
10573 * "parameter": optional String | |
10574 * "propagatedType": optional String | |
10575 * "staticType": optional String | |
10576 * } | |
10577 */ | |
10578 class HoverInformation implements HasToJson { | |
10579 int _offset; | |
10580 | |
10581 int _length; | |
10582 | |
10583 String _containingLibraryPath; | |
10584 | |
10585 String _containingLibraryName; | |
10586 | |
10587 String _containingClassDescription; | |
10588 | |
10589 String _dartdoc; | |
10590 | |
10591 String _elementDescription; | |
10592 | |
10593 String _elementKind; | |
10594 | |
10595 String _parameter; | |
10596 | |
10597 String _propagatedType; | |
10598 | |
10599 String _staticType; | |
10600 | |
10601 /** | |
10602 * The offset of the range of characters that encompases the cursor position | |
10603 * and has the same hover information as the cursor position. | |
10604 */ | |
10605 int get offset => _offset; | |
10606 | |
10607 /** | |
10608 * The offset of the range of characters that encompases the cursor position | |
10609 * and has the same hover information as the cursor position. | |
10610 */ | |
10611 void set offset(int value) { | |
10612 assert(value != null); | |
10613 this._offset = value; | |
10614 } | |
10615 | |
10616 /** | |
10617 * The length of the range of characters that encompases the cursor position | |
10618 * and has the same hover information as the cursor position. | |
10619 */ | |
10620 int get length => _length; | |
10621 | |
10622 /** | |
10623 * The length of the range of characters that encompases the cursor position | |
10624 * and has the same hover information as the cursor position. | |
10625 */ | |
10626 void set length(int value) { | |
10627 assert(value != null); | |
10628 this._length = value; | |
10629 } | |
10630 | |
10631 /** | |
10632 * The path to the defining compilation unit of the library in which the | |
10633 * referenced element is declared. This data is omitted if there is no | |
10634 * referenced element, or if the element is declared inside an HTML file. | |
10635 */ | |
10636 String get containingLibraryPath => _containingLibraryPath; | |
10637 | |
10638 /** | |
10639 * The path to the defining compilation unit of the library in which the | |
10640 * referenced element is declared. This data is omitted if there is no | |
10641 * referenced element, or if the element is declared inside an HTML file. | |
10642 */ | |
10643 void set containingLibraryPath(String value) { | |
10644 this._containingLibraryPath = value; | |
10645 } | |
10646 | |
10647 /** | |
10648 * The name of the library in which the referenced element is declared. This | |
10649 * data is omitted if there is no referenced element, or if the element is | |
10650 * declared inside an HTML file. | |
10651 */ | |
10652 String get containingLibraryName => _containingLibraryName; | |
10653 | |
10654 /** | |
10655 * The name of the library in which the referenced element is declared. This | |
10656 * data is omitted if there is no referenced element, or if the element is | |
10657 * declared inside an HTML file. | |
10658 */ | |
10659 void set containingLibraryName(String value) { | |
10660 this._containingLibraryName = value; | |
10661 } | |
10662 | |
10663 /** | |
10664 * A human-readable description of the class declaring the element being | |
10665 * referenced. This data is omitted if there is no referenced element, or if | |
10666 * the element is not a class member. | |
10667 */ | |
10668 String get containingClassDescription => _containingClassDescription; | |
10669 | |
10670 /** | |
10671 * A human-readable description of the class declaring the element being | |
10672 * referenced. This data is omitted if there is no referenced element, or if | |
10673 * the element is not a class member. | |
10674 */ | |
10675 void set containingClassDescription(String value) { | |
10676 this._containingClassDescription = value; | |
10677 } | |
10678 | |
10679 /** | |
10680 * The dartdoc associated with the referenced element. Other than the removal | |
10681 * of the comment delimiters, including leading asterisks in the case of a | |
10682 * block comment, the dartdoc is unprocessed markdown. This data is omitted | |
10683 * if there is no referenced element, or if the element has no dartdoc. | |
10684 */ | |
10685 String get dartdoc => _dartdoc; | |
10686 | |
10687 /** | |
10688 * The dartdoc associated with the referenced element. Other than the removal | |
10689 * of the comment delimiters, including leading asterisks in the case of a | |
10690 * block comment, the dartdoc is unprocessed markdown. This data is omitted | |
10691 * if there is no referenced element, or if the element has no dartdoc. | |
10692 */ | |
10693 void set dartdoc(String value) { | |
10694 this._dartdoc = value; | |
10695 } | |
10696 | |
10697 /** | |
10698 * A human-readable description of the element being referenced. This data is | |
10699 * omitted if there is no referenced element. | |
10700 */ | |
10701 String get elementDescription => _elementDescription; | |
10702 | |
10703 /** | |
10704 * A human-readable description of the element being referenced. This data is | |
10705 * omitted if there is no referenced element. | |
10706 */ | |
10707 void set elementDescription(String value) { | |
10708 this._elementDescription = value; | |
10709 } | |
10710 | |
10711 /** | |
10712 * A human-readable description of the kind of element being referenced (such | |
10713 * as “class” or “function type alias”). This data is omitted if there is no | |
10714 * referenced element. | |
10715 */ | |
10716 String get elementKind => _elementKind; | |
10717 | |
10718 /** | |
10719 * A human-readable description of the kind of element being referenced (such | |
10720 * as “class” or “function type alias”). This data is omitted if there is no | |
10721 * referenced element. | |
10722 */ | |
10723 void set elementKind(String value) { | |
10724 this._elementKind = value; | |
10725 } | |
10726 | |
10727 /** | |
10728 * A human-readable description of the parameter corresponding to the | |
10729 * expression being hovered over. This data is omitted if the location is not | |
10730 * in an argument to a function. | |
10731 */ | |
10732 String get parameter => _parameter; | |
10733 | |
10734 /** | |
10735 * A human-readable description of the parameter corresponding to the | |
10736 * expression being hovered over. This data is omitted if the location is not | |
10737 * in an argument to a function. | |
10738 */ | |
10739 void set parameter(String value) { | |
10740 this._parameter = value; | |
10741 } | |
10742 | |
10743 /** | |
10744 * The name of the propagated type of the expression. This data is omitted if | |
10745 * the location does not correspond to an expression or if there is no | |
10746 * propagated type information. | |
10747 */ | |
10748 String get propagatedType => _propagatedType; | |
10749 | |
10750 /** | |
10751 * The name of the propagated type of the expression. This data is omitted if | |
10752 * the location does not correspond to an expression or if there is no | |
10753 * propagated type information. | |
10754 */ | |
10755 void set propagatedType(String value) { | |
10756 this._propagatedType = value; | |
10757 } | |
10758 | |
10759 /** | |
10760 * The name of the static type of the expression. This data is omitted if the | |
10761 * location does not correspond to an expression. | |
10762 */ | |
10763 String get staticType => _staticType; | |
10764 | |
10765 /** | |
10766 * The name of the static type of the expression. This data is omitted if the | |
10767 * location does not correspond to an expression. | |
10768 */ | |
10769 void set staticType(String value) { | |
10770 this._staticType = value; | |
10771 } | |
10772 | |
10773 HoverInformation(int offset, int length, {String containingLibraryPath, String
containingLibraryName, String containingClassDescription, String dartdoc, Strin
g elementDescription, String elementKind, String parameter, String propagatedTyp
e, String staticType}) { | |
10774 this.offset = offset; | |
10775 this.length = length; | |
10776 this.containingLibraryPath = containingLibraryPath; | |
10777 this.containingLibraryName = containingLibraryName; | |
10778 this.containingClassDescription = containingClassDescription; | |
10779 this.dartdoc = dartdoc; | |
10780 this.elementDescription = elementDescription; | |
10781 this.elementKind = elementKind; | |
10782 this.parameter = parameter; | |
10783 this.propagatedType = propagatedType; | |
10784 this.staticType = staticType; | |
10785 } | |
10786 | |
10787 factory HoverInformation.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
10788 if (json == null) { | |
10789 json = {}; | |
10790 } | |
10791 if (json is Map) { | |
10792 int offset; | |
10793 if (json.containsKey("offset")) { | |
10794 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
10795 } else { | |
10796 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
10797 } | |
10798 int length; | |
10799 if (json.containsKey("length")) { | |
10800 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
10801 } else { | |
10802 throw jsonDecoder.missingKey(jsonPath, "length"); | |
10803 } | |
10804 String containingLibraryPath; | |
10805 if (json.containsKey("containingLibraryPath")) { | |
10806 containingLibraryPath = jsonDecoder._decodeString(jsonPath + ".containin
gLibraryPath", json["containingLibraryPath"]); | |
10807 } | |
10808 String containingLibraryName; | |
10809 if (json.containsKey("containingLibraryName")) { | |
10810 containingLibraryName = jsonDecoder._decodeString(jsonPath + ".containin
gLibraryName", json["containingLibraryName"]); | |
10811 } | |
10812 String containingClassDescription; | |
10813 if (json.containsKey("containingClassDescription")) { | |
10814 containingClassDescription = jsonDecoder._decodeString(jsonPath + ".cont
ainingClassDescription", json["containingClassDescription"]); | |
10815 } | |
10816 String dartdoc; | |
10817 if (json.containsKey("dartdoc")) { | |
10818 dartdoc = jsonDecoder._decodeString(jsonPath + ".dartdoc", json["dartdoc
"]); | |
10819 } | |
10820 String elementDescription; | |
10821 if (json.containsKey("elementDescription")) { | |
10822 elementDescription = jsonDecoder._decodeString(jsonPath + ".elementDescr
iption", json["elementDescription"]); | |
10823 } | |
10824 String elementKind; | |
10825 if (json.containsKey("elementKind")) { | |
10826 elementKind = jsonDecoder._decodeString(jsonPath + ".elementKind", json[
"elementKind"]); | |
10827 } | |
10828 String parameter; | |
10829 if (json.containsKey("parameter")) { | |
10830 parameter = jsonDecoder._decodeString(jsonPath + ".parameter", json["par
ameter"]); | |
10831 } | |
10832 String propagatedType; | |
10833 if (json.containsKey("propagatedType")) { | |
10834 propagatedType = jsonDecoder._decodeString(jsonPath + ".propagatedType",
json["propagatedType"]); | |
10835 } | |
10836 String staticType; | |
10837 if (json.containsKey("staticType")) { | |
10838 staticType = jsonDecoder._decodeString(jsonPath + ".staticType", json["s
taticType"]); | |
10839 } | |
10840 return new HoverInformation(offset, length, containingLibraryPath: contain
ingLibraryPath, containingLibraryName: containingLibraryName, containingClassDes
cription: containingClassDescription, dartdoc: dartdoc, elementDescription: elem
entDescription, elementKind: elementKind, parameter: parameter, propagatedType:
propagatedType, staticType: staticType); | |
10841 } else { | |
10842 throw jsonDecoder.mismatch(jsonPath, "HoverInformation", json); | |
10843 } | |
10844 } | |
10845 | |
10846 Map<String, dynamic> toJson() { | |
10847 Map<String, dynamic> result = {}; | |
10848 result["offset"] = offset; | |
10849 result["length"] = length; | |
10850 if (containingLibraryPath != null) { | |
10851 result["containingLibraryPath"] = containingLibraryPath; | |
10852 } | |
10853 if (containingLibraryName != null) { | |
10854 result["containingLibraryName"] = containingLibraryName; | |
10855 } | |
10856 if (containingClassDescription != null) { | |
10857 result["containingClassDescription"] = containingClassDescription; | |
10858 } | |
10859 if (dartdoc != null) { | |
10860 result["dartdoc"] = dartdoc; | |
10861 } | |
10862 if (elementDescription != null) { | |
10863 result["elementDescription"] = elementDescription; | |
10864 } | |
10865 if (elementKind != null) { | |
10866 result["elementKind"] = elementKind; | |
10867 } | |
10868 if (parameter != null) { | |
10869 result["parameter"] = parameter; | |
10870 } | |
10871 if (propagatedType != null) { | |
10872 result["propagatedType"] = propagatedType; | |
10873 } | |
10874 if (staticType != null) { | |
10875 result["staticType"] = staticType; | |
10876 } | |
10877 return result; | |
10878 } | |
10879 | |
10880 @override | |
10881 String toString() => JSON.encode(toJson()); | |
10882 | |
10883 @override | |
10884 bool operator==(other) { | |
10885 if (other is HoverInformation) { | |
10886 return offset == other.offset && | |
10887 length == other.length && | |
10888 containingLibraryPath == other.containingLibraryPath && | |
10889 containingLibraryName == other.containingLibraryName && | |
10890 containingClassDescription == other.containingClassDescription && | |
10891 dartdoc == other.dartdoc && | |
10892 elementDescription == other.elementDescription && | |
10893 elementKind == other.elementKind && | |
10894 parameter == other.parameter && | |
10895 propagatedType == other.propagatedType && | |
10896 staticType == other.staticType; | |
10897 } | |
10898 return false; | |
10899 } | |
10900 | |
10901 @override | |
10902 int get hashCode { | |
10903 int hash = 0; | |
10904 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
10905 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
10906 hash = _JenkinsSmiHash.combine(hash, containingLibraryPath.hashCode); | |
10907 hash = _JenkinsSmiHash.combine(hash, containingLibraryName.hashCode); | |
10908 hash = _JenkinsSmiHash.combine(hash, containingClassDescription.hashCode); | |
10909 hash = _JenkinsSmiHash.combine(hash, dartdoc.hashCode); | |
10910 hash = _JenkinsSmiHash.combine(hash, elementDescription.hashCode); | |
10911 hash = _JenkinsSmiHash.combine(hash, elementKind.hashCode); | |
10912 hash = _JenkinsSmiHash.combine(hash, parameter.hashCode); | |
10913 hash = _JenkinsSmiHash.combine(hash, propagatedType.hashCode); | |
10914 hash = _JenkinsSmiHash.combine(hash, staticType.hashCode); | |
10915 return _JenkinsSmiHash.finish(hash); | |
10916 } | |
10917 } | |
10918 | |
10919 /** | |
10920 * ImplementedClass | |
10921 * | |
10922 * { | |
10923 * "offset": int | |
10924 * "length": int | |
10925 * } | |
10926 */ | |
10927 class ImplementedClass implements HasToJson { | |
10928 int _offset; | |
10929 | |
10930 int _length; | |
10931 | |
10932 /** | |
10933 * The offset of the name of the implemented class. | |
10934 */ | |
10935 int get offset => _offset; | |
10936 | |
10937 /** | |
10938 * The offset of the name of the implemented class. | |
10939 */ | |
10940 void set offset(int value) { | |
10941 assert(value != null); | |
10942 this._offset = value; | |
10943 } | |
10944 | |
10945 /** | |
10946 * The length of the name of the implemented class. | |
10947 */ | |
10948 int get length => _length; | |
10949 | |
10950 /** | |
10951 * The length of the name of the implemented class. | |
10952 */ | |
10953 void set length(int value) { | |
10954 assert(value != null); | |
10955 this._length = value; | |
10956 } | |
10957 | |
10958 ImplementedClass(int offset, int length) { | |
10959 this.offset = offset; | |
10960 this.length = length; | |
10961 } | |
10962 | |
10963 factory ImplementedClass.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
10964 if (json == null) { | |
10965 json = {}; | |
10966 } | |
10967 if (json is Map) { | |
10968 int offset; | |
10969 if (json.containsKey("offset")) { | |
10970 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
10971 } else { | |
10972 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
10973 } | |
10974 int length; | |
10975 if (json.containsKey("length")) { | |
10976 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
10977 } else { | |
10978 throw jsonDecoder.missingKey(jsonPath, "length"); | |
10979 } | |
10980 return new ImplementedClass(offset, length); | |
10981 } else { | |
10982 throw jsonDecoder.mismatch(jsonPath, "ImplementedClass", json); | |
10983 } | |
10984 } | |
10985 | |
10986 Map<String, dynamic> toJson() { | |
10987 Map<String, dynamic> result = {}; | |
10988 result["offset"] = offset; | |
10989 result["length"] = length; | |
10990 return result; | |
10991 } | |
10992 | |
10993 @override | |
10994 String toString() => JSON.encode(toJson()); | |
10995 | |
10996 @override | |
10997 bool operator==(other) { | |
10998 if (other is ImplementedClass) { | |
10999 return offset == other.offset && | |
11000 length == other.length; | |
11001 } | |
11002 return false; | |
11003 } | |
11004 | |
11005 @override | |
11006 int get hashCode { | |
11007 int hash = 0; | |
11008 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
11009 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
11010 return _JenkinsSmiHash.finish(hash); | |
11011 } | |
11012 } | |
11013 | |
11014 /** | |
11015 * ImplementedMember | |
11016 * | |
11017 * { | |
11018 * "offset": int | |
11019 * "length": int | |
11020 * } | |
11021 */ | |
11022 class ImplementedMember implements HasToJson { | |
11023 int _offset; | |
11024 | |
11025 int _length; | |
11026 | |
11027 /** | |
11028 * The offset of the name of the implemented member. | |
11029 */ | |
11030 int get offset => _offset; | |
11031 | |
11032 /** | |
11033 * The offset of the name of the implemented member. | |
11034 */ | |
11035 void set offset(int value) { | |
11036 assert(value != null); | |
11037 this._offset = value; | |
11038 } | |
11039 | |
11040 /** | |
11041 * The length of the name of the implemented member. | |
11042 */ | |
11043 int get length => _length; | |
11044 | |
11045 /** | |
11046 * The length of the name of the implemented member. | |
11047 */ | |
11048 void set length(int value) { | |
11049 assert(value != null); | |
11050 this._length = value; | |
11051 } | |
11052 | |
11053 ImplementedMember(int offset, int length) { | |
11054 this.offset = offset; | |
11055 this.length = length; | |
11056 } | |
11057 | |
11058 factory ImplementedMember.fromJson(JsonDecoder jsonDecoder, String jsonPath, O
bject json) { | |
11059 if (json == null) { | |
11060 json = {}; | |
11061 } | |
11062 if (json is Map) { | |
11063 int offset; | |
11064 if (json.containsKey("offset")) { | |
11065 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
11066 } else { | |
11067 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
11068 } | |
11069 int length; | |
11070 if (json.containsKey("length")) { | |
11071 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
11072 } else { | |
11073 throw jsonDecoder.missingKey(jsonPath, "length"); | |
11074 } | |
11075 return new ImplementedMember(offset, length); | |
11076 } else { | |
11077 throw jsonDecoder.mismatch(jsonPath, "ImplementedMember", json); | |
11078 } | |
11079 } | |
11080 | |
11081 Map<String, dynamic> toJson() { | |
11082 Map<String, dynamic> result = {}; | |
11083 result["offset"] = offset; | |
11084 result["length"] = length; | |
11085 return result; | |
11086 } | |
11087 | |
11088 @override | |
11089 String toString() => JSON.encode(toJson()); | |
11090 | |
11091 @override | |
11092 bool operator==(other) { | |
11093 if (other is ImplementedMember) { | |
11094 return offset == other.offset && | |
11095 length == other.length; | |
11096 } | |
11097 return false; | |
11098 } | |
11099 | |
11100 @override | |
11101 int get hashCode { | |
11102 int hash = 0; | |
11103 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
11104 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
11105 return _JenkinsSmiHash.finish(hash); | |
11106 } | |
11107 } | |
11108 | |
11109 /** | |
11110 * LinkedEditGroup | |
11111 * | |
11112 * { | |
11113 * "positions": List<Position> | |
11114 * "length": int | |
11115 * "suggestions": List<LinkedEditSuggestion> | |
11116 * } | |
11117 */ | |
11118 class LinkedEditGroup implements HasToJson { | |
11119 List<Position> _positions; | |
11120 | |
11121 int _length; | |
11122 | |
11123 List<LinkedEditSuggestion> _suggestions; | |
11124 | |
11125 /** | |
11126 * The positions of the regions that should be edited simultaneously. | |
11127 */ | |
11128 List<Position> get positions => _positions; | |
11129 | |
11130 /** | |
11131 * The positions of the regions that should be edited simultaneously. | |
11132 */ | |
11133 void set positions(List<Position> value) { | |
11134 assert(value != null); | |
11135 this._positions = value; | |
11136 } | |
11137 | |
11138 /** | |
11139 * The length of the regions that should be edited simultaneously. | |
11140 */ | |
11141 int get length => _length; | |
11142 | |
11143 /** | |
11144 * The length of the regions that should be edited simultaneously. | |
11145 */ | |
11146 void set length(int value) { | |
11147 assert(value != null); | |
11148 this._length = value; | |
11149 } | |
11150 | |
11151 /** | |
11152 * Pre-computed suggestions for what every region might want to be changed | |
11153 * to. | |
11154 */ | |
11155 List<LinkedEditSuggestion> get suggestions => _suggestions; | |
11156 | |
11157 /** | |
11158 * Pre-computed suggestions for what every region might want to be changed | |
11159 * to. | |
11160 */ | |
11161 void set suggestions(List<LinkedEditSuggestion> value) { | |
11162 assert(value != null); | |
11163 this._suggestions = value; | |
11164 } | |
11165 | |
11166 LinkedEditGroup(List<Position> positions, int length, List<LinkedEditSuggestio
n> suggestions) { | |
11167 this.positions = positions; | |
11168 this.length = length; | |
11169 this.suggestions = suggestions; | |
11170 } | |
11171 | |
11172 factory LinkedEditGroup.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obj
ect json) { | |
11173 if (json == null) { | |
11174 json = {}; | |
11175 } | |
11176 if (json is Map) { | |
11177 List<Position> positions; | |
11178 if (json.containsKey("positions")) { | |
11179 positions = jsonDecoder._decodeList(jsonPath + ".positions", json["posit
ions"], (String jsonPath, Object json) => new Position.fromJson(jsonDecoder, jso
nPath, json)); | |
11180 } else { | |
11181 throw jsonDecoder.missingKey(jsonPath, "positions"); | |
11182 } | |
11183 int length; | |
11184 if (json.containsKey("length")) { | |
11185 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
11186 } else { | |
11187 throw jsonDecoder.missingKey(jsonPath, "length"); | |
11188 } | |
11189 List<LinkedEditSuggestion> suggestions; | |
11190 if (json.containsKey("suggestions")) { | |
11191 suggestions = jsonDecoder._decodeList(jsonPath + ".suggestions", json["s
uggestions"], (String jsonPath, Object json) => new LinkedEditSuggestion.fromJso
n(jsonDecoder, jsonPath, json)); | |
11192 } else { | |
11193 throw jsonDecoder.missingKey(jsonPath, "suggestions"); | |
11194 } | |
11195 return new LinkedEditGroup(positions, length, suggestions); | |
11196 } else { | |
11197 throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup", json); | |
11198 } | |
11199 } | |
11200 | |
11201 /** | |
11202 * Construct an empty LinkedEditGroup. | |
11203 */ | |
11204 LinkedEditGroup.empty() : this(<Position>[], 0, <LinkedEditSuggestion>[]); | |
11205 | |
11206 Map<String, dynamic> toJson() { | |
11207 Map<String, dynamic> result = {}; | |
11208 result["positions"] = positions.map((Position value) => value.toJson()).toLi
st(); | |
11209 result["length"] = length; | |
11210 result["suggestions"] = suggestions.map((LinkedEditSuggestion value) => valu
e.toJson()).toList(); | |
11211 return result; | |
11212 } | |
11213 | |
11214 /** | |
11215 * Add a new position and change the length. | |
11216 */ | |
11217 void addPosition(Position position, int length) { | |
11218 positions.add(position); | |
11219 this.length = length; | |
11220 } | |
11221 | |
11222 /** | |
11223 * Add a new suggestion. | |
11224 */ | |
11225 void addSuggestion(LinkedEditSuggestion suggestion) { | |
11226 suggestions.add(suggestion); | |
11227 } | |
11228 | |
11229 @override | |
11230 String toString() => JSON.encode(toJson()); | |
11231 | |
11232 @override | |
11233 bool operator==(other) { | |
11234 if (other is LinkedEditGroup) { | |
11235 return _listEqual(positions, other.positions, (Position a, Position b) =>
a == b) && | |
11236 length == other.length && | |
11237 _listEqual(suggestions, other.suggestions, (LinkedEditSuggestion a, Li
nkedEditSuggestion b) => a == b); | |
11238 } | |
11239 return false; | |
11240 } | |
11241 | |
11242 @override | |
11243 int get hashCode { | |
11244 int hash = 0; | |
11245 hash = _JenkinsSmiHash.combine(hash, positions.hashCode); | |
11246 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
11247 hash = _JenkinsSmiHash.combine(hash, suggestions.hashCode); | |
11248 return _JenkinsSmiHash.finish(hash); | |
11249 } | |
11250 } | |
11251 | |
11252 /** | |
11253 * LinkedEditSuggestion | |
11254 * | |
11255 * { | |
11256 * "value": String | |
11257 * "kind": LinkedEditSuggestionKind | |
11258 * } | |
11259 */ | |
11260 class LinkedEditSuggestion implements HasToJson { | |
11261 String _value; | |
11262 | |
11263 LinkedEditSuggestionKind _kind; | |
11264 | |
11265 /** | |
11266 * The value that could be used to replace all of the linked edit regions. | |
11267 */ | |
11268 String get value => _value; | |
11269 | |
11270 /** | |
11271 * The value that could be used to replace all of the linked edit regions. | |
11272 */ | |
11273 void set value(String value) { | |
11274 assert(value != null); | |
11275 this._value = value; | |
11276 } | |
11277 | |
11278 /** | |
11279 * The kind of value being proposed. | |
11280 */ | |
11281 LinkedEditSuggestionKind get kind => _kind; | |
11282 | |
11283 /** | |
11284 * The kind of value being proposed. | |
11285 */ | |
11286 void set kind(LinkedEditSuggestionKind value) { | |
11287 assert(value != null); | |
11288 this._kind = value; | |
11289 } | |
11290 | |
11291 LinkedEditSuggestion(String value, LinkedEditSuggestionKind kind) { | |
11292 this.value = value; | |
11293 this.kind = kind; | |
11294 } | |
11295 | |
11296 factory LinkedEditSuggestion.fromJson(JsonDecoder jsonDecoder, String jsonPath
, Object json) { | |
11297 if (json == null) { | |
11298 json = {}; | |
11299 } | |
11300 if (json is Map) { | |
11301 String value; | |
11302 if (json.containsKey("value")) { | |
11303 value = jsonDecoder._decodeString(jsonPath + ".value", json["value"]); | |
11304 } else { | |
11305 throw jsonDecoder.missingKey(jsonPath, "value"); | |
11306 } | |
11307 LinkedEditSuggestionKind kind; | |
11308 if (json.containsKey("kind")) { | |
11309 kind = new LinkedEditSuggestionKind.fromJson(jsonDecoder, jsonPath + ".k
ind", json["kind"]); | |
11310 } else { | |
11311 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
11312 } | |
11313 return new LinkedEditSuggestion(value, kind); | |
11314 } else { | |
11315 throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestion", json); | |
11316 } | |
11317 } | |
11318 | |
11319 Map<String, dynamic> toJson() { | |
11320 Map<String, dynamic> result = {}; | |
11321 result["value"] = value; | |
11322 result["kind"] = kind.toJson(); | |
11323 return result; | |
11324 } | |
11325 | |
11326 @override | |
11327 String toString() => JSON.encode(toJson()); | |
11328 | |
11329 @override | |
11330 bool operator==(other) { | |
11331 if (other is LinkedEditSuggestion) { | |
11332 return value == other.value && | |
11333 kind == other.kind; | |
11334 } | |
11335 return false; | |
11336 } | |
11337 | |
11338 @override | |
11339 int get hashCode { | |
11340 int hash = 0; | |
11341 hash = _JenkinsSmiHash.combine(hash, value.hashCode); | |
11342 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
11343 return _JenkinsSmiHash.finish(hash); | |
11344 } | |
11345 } | |
11346 | |
11347 /** | |
11348 * LinkedEditSuggestionKind | |
11349 * | |
11350 * enum { | |
11351 * METHOD | |
11352 * PARAMETER | |
11353 * TYPE | |
11354 * VARIABLE | |
11355 * } | |
11356 */ | |
11357 class LinkedEditSuggestionKind implements Enum { | |
11358 static const METHOD = const LinkedEditSuggestionKind._("METHOD"); | |
11359 | |
11360 static const PARAMETER = const LinkedEditSuggestionKind._("PARAMETER"); | |
11361 | |
11362 static const TYPE = const LinkedEditSuggestionKind._("TYPE"); | |
11363 | |
11364 static const VARIABLE = const LinkedEditSuggestionKind._("VARIABLE"); | |
11365 | |
11366 /** | |
11367 * A list containing all of the enum values that are defined. | |
11368 */ | |
11369 static const List<LinkedEditSuggestionKind> VALUES = const <LinkedEditSuggesti
onKind>[METHOD, PARAMETER, TYPE, VARIABLE]; | |
11370 | |
11371 final String name; | |
11372 | |
11373 const LinkedEditSuggestionKind._(this.name); | |
11374 | |
11375 factory LinkedEditSuggestionKind(String name) { | |
11376 switch (name) { | |
11377 case "METHOD": | |
11378 return METHOD; | |
11379 case "PARAMETER": | |
11380 return PARAMETER; | |
11381 case "TYPE": | |
11382 return TYPE; | |
11383 case "VARIABLE": | |
11384 return VARIABLE; | |
11385 } | |
11386 throw new Exception('Illegal enum value: $name'); | |
11387 } | |
11388 | |
11389 factory LinkedEditSuggestionKind.fromJson(JsonDecoder jsonDecoder, String json
Path, Object json) { | |
11390 if (json is String) { | |
11391 try { | |
11392 return new LinkedEditSuggestionKind(json); | |
11393 } catch(_) { | |
11394 // Fall through | |
11395 } | |
11396 } | |
11397 throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestionKind", json); | |
11398 } | |
11399 | |
11400 @override | |
11401 String toString() => "LinkedEditSuggestionKind.$name"; | |
11402 | |
11403 String toJson() => name; | |
11404 } | |
11405 | |
11406 /** | |
11407 * Location | |
11408 * | |
11409 * { | |
11410 * "file": FilePath | |
11411 * "offset": int | |
11412 * "length": int | |
11413 * "startLine": int | |
11414 * "startColumn": int | |
11415 * } | |
11416 */ | |
11417 class Location implements HasToJson { | |
11418 String _file; | |
11419 | |
11420 int _offset; | |
11421 | |
11422 int _length; | |
11423 | |
11424 int _startLine; | |
11425 | |
11426 int _startColumn; | |
11427 | |
11428 /** | |
11429 * The file containing the range. | |
11430 */ | |
11431 String get file => _file; | |
11432 | |
11433 /** | |
11434 * The file containing the range. | |
11435 */ | |
11436 void set file(String value) { | |
11437 assert(value != null); | |
11438 this._file = value; | |
11439 } | |
11440 | |
11441 /** | |
11442 * The offset of the range. | |
11443 */ | |
11444 int get offset => _offset; | |
11445 | |
11446 /** | |
11447 * The offset of the range. | |
11448 */ | |
11449 void set offset(int value) { | |
11450 assert(value != null); | |
11451 this._offset = value; | |
11452 } | |
11453 | |
11454 /** | |
11455 * The length of the range. | |
11456 */ | |
11457 int get length => _length; | |
11458 | |
11459 /** | |
11460 * The length of the range. | |
11461 */ | |
11462 void set length(int value) { | |
11463 assert(value != null); | |
11464 this._length = value; | |
11465 } | |
11466 | |
11467 /** | |
11468 * The one-based index of the line containing the first character of the | |
11469 * range. | |
11470 */ | |
11471 int get startLine => _startLine; | |
11472 | |
11473 /** | |
11474 * The one-based index of the line containing the first character of the | |
11475 * range. | |
11476 */ | |
11477 void set startLine(int value) { | |
11478 assert(value != null); | |
11479 this._startLine = value; | |
11480 } | |
11481 | |
11482 /** | |
11483 * The one-based index of the column containing the first character of the | |
11484 * range. | |
11485 */ | |
11486 int get startColumn => _startColumn; | |
11487 | |
11488 /** | |
11489 * The one-based index of the column containing the first character of the | |
11490 * range. | |
11491 */ | |
11492 void set startColumn(int value) { | |
11493 assert(value != null); | |
11494 this._startColumn = value; | |
11495 } | |
11496 | |
11497 Location(String file, int offset, int length, int startLine, int startColumn)
{ | |
11498 this.file = file; | |
11499 this.offset = offset; | |
11500 this.length = length; | |
11501 this.startLine = startLine; | |
11502 this.startColumn = startColumn; | |
11503 } | |
11504 | |
11505 factory Location.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object jso
n) { | |
11506 if (json == null) { | |
11507 json = {}; | |
11508 } | |
11509 if (json is Map) { | |
11510 String file; | |
11511 if (json.containsKey("file")) { | |
11512 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
11513 } else { | |
11514 throw jsonDecoder.missingKey(jsonPath, "file"); | |
11515 } | |
11516 int offset; | |
11517 if (json.containsKey("offset")) { | |
11518 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
11519 } else { | |
11520 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
11521 } | |
11522 int length; | |
11523 if (json.containsKey("length")) { | |
11524 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
11525 } else { | |
11526 throw jsonDecoder.missingKey(jsonPath, "length"); | |
11527 } | |
11528 int startLine; | |
11529 if (json.containsKey("startLine")) { | |
11530 startLine = jsonDecoder._decodeInt(jsonPath + ".startLine", json["startL
ine"]); | |
11531 } else { | |
11532 throw jsonDecoder.missingKey(jsonPath, "startLine"); | |
11533 } | |
11534 int startColumn; | |
11535 if (json.containsKey("startColumn")) { | |
11536 startColumn = jsonDecoder._decodeInt(jsonPath + ".startColumn", json["st
artColumn"]); | |
11537 } else { | |
11538 throw jsonDecoder.missingKey(jsonPath, "startColumn"); | |
11539 } | |
11540 return new Location(file, offset, length, startLine, startColumn); | |
11541 } else { | |
11542 throw jsonDecoder.mismatch(jsonPath, "Location", json); | |
11543 } | |
11544 } | |
11545 | |
11546 Map<String, dynamic> toJson() { | |
11547 Map<String, dynamic> result = {}; | |
11548 result["file"] = file; | |
11549 result["offset"] = offset; | |
11550 result["length"] = length; | |
11551 result["startLine"] = startLine; | |
11552 result["startColumn"] = startColumn; | |
11553 return result; | |
11554 } | |
11555 | |
11556 @override | |
11557 String toString() => JSON.encode(toJson()); | |
11558 | |
11559 @override | |
11560 bool operator==(other) { | |
11561 if (other is Location) { | |
11562 return file == other.file && | |
11563 offset == other.offset && | |
11564 length == other.length && | |
11565 startLine == other.startLine && | |
11566 startColumn == other.startColumn; | |
11567 } | |
11568 return false; | |
11569 } | |
11570 | |
11571 @override | |
11572 int get hashCode { | |
11573 int hash = 0; | |
11574 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
11575 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
11576 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
11577 hash = _JenkinsSmiHash.combine(hash, startLine.hashCode); | |
11578 hash = _JenkinsSmiHash.combine(hash, startColumn.hashCode); | |
11579 return _JenkinsSmiHash.finish(hash); | |
11580 } | |
11581 } | |
11582 | |
11583 /** | |
11584 * NavigationRegion | |
11585 * | |
11586 * { | |
11587 * "offset": int | |
11588 * "length": int | |
11589 * "targets": List<int> | |
11590 * } | |
11591 */ | |
11592 class NavigationRegion implements HasToJson { | |
11593 int _offset; | |
11594 | |
11595 int _length; | |
11596 | |
11597 List<int> _targets; | |
11598 | |
11599 /** | |
11600 * The offset of the region from which the user can navigate. | |
11601 */ | |
11602 int get offset => _offset; | |
11603 | |
11604 /** | |
11605 * The offset of the region from which the user can navigate. | |
11606 */ | |
11607 void set offset(int value) { | |
11608 assert(value != null); | |
11609 this._offset = value; | |
11610 } | |
11611 | |
11612 /** | |
11613 * The length of the region from which the user can navigate. | |
11614 */ | |
11615 int get length => _length; | |
11616 | |
11617 /** | |
11618 * The length of the region from which the user can navigate. | |
11619 */ | |
11620 void set length(int value) { | |
11621 assert(value != null); | |
11622 this._length = value; | |
11623 } | |
11624 | |
11625 /** | |
11626 * The indexes of the targets (in the enclosing navigation response) to which | |
11627 * the given region is bound. By opening the target, clients can implement | |
11628 * one form of navigation. This list cannot be empty. | |
11629 */ | |
11630 List<int> get targets => _targets; | |
11631 | |
11632 /** | |
11633 * The indexes of the targets (in the enclosing navigation response) to which | |
11634 * the given region is bound. By opening the target, clients can implement | |
11635 * one form of navigation. This list cannot be empty. | |
11636 */ | |
11637 void set targets(List<int> value) { | |
11638 assert(value != null); | |
11639 this._targets = value; | |
11640 } | |
11641 | |
11642 NavigationRegion(int offset, int length, List<int> targets) { | |
11643 this.offset = offset; | |
11644 this.length = length; | |
11645 this.targets = targets; | |
11646 } | |
11647 | |
11648 factory NavigationRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
11649 if (json == null) { | |
11650 json = {}; | |
11651 } | |
11652 if (json is Map) { | |
11653 int offset; | |
11654 if (json.containsKey("offset")) { | |
11655 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
11656 } else { | |
11657 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
11658 } | |
11659 int length; | |
11660 if (json.containsKey("length")) { | |
11661 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
11662 } else { | |
11663 throw jsonDecoder.missingKey(jsonPath, "length"); | |
11664 } | |
11665 List<int> targets; | |
11666 if (json.containsKey("targets")) { | |
11667 targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"]
, jsonDecoder._decodeInt); | |
11668 } else { | |
11669 throw jsonDecoder.missingKey(jsonPath, "targets"); | |
11670 } | |
11671 return new NavigationRegion(offset, length, targets); | |
11672 } else { | |
11673 throw jsonDecoder.mismatch(jsonPath, "NavigationRegion", json); | |
11674 } | |
11675 } | |
11676 | |
11677 Map<String, dynamic> toJson() { | |
11678 Map<String, dynamic> result = {}; | |
11679 result["offset"] = offset; | |
11680 result["length"] = length; | |
11681 result["targets"] = targets; | |
11682 return result; | |
11683 } | |
11684 | |
11685 @override | |
11686 String toString() => JSON.encode(toJson()); | |
11687 | |
11688 @override | |
11689 bool operator==(other) { | |
11690 if (other is NavigationRegion) { | |
11691 return offset == other.offset && | |
11692 length == other.length && | |
11693 _listEqual(targets, other.targets, (int a, int b) => a == b); | |
11694 } | |
11695 return false; | |
11696 } | |
11697 | |
11698 @override | |
11699 int get hashCode { | |
11700 int hash = 0; | |
11701 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
11702 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
11703 hash = _JenkinsSmiHash.combine(hash, targets.hashCode); | |
11704 return _JenkinsSmiHash.finish(hash); | |
11705 } | |
11706 } | |
11707 | |
11708 /** | |
11709 * NavigationTarget | |
11710 * | |
11711 * { | |
11712 * "kind": ElementKind | |
11713 * "fileIndex": int | |
11714 * "offset": int | |
11715 * "length": int | |
11716 * "startLine": int | |
11717 * "startColumn": int | |
11718 * } | |
11719 */ | |
11720 class NavigationTarget implements HasToJson { | |
11721 ElementKind _kind; | |
11722 | |
11723 int _fileIndex; | |
11724 | |
11725 int _offset; | |
11726 | |
11727 int _length; | |
11728 | |
11729 int _startLine; | |
11730 | |
11731 int _startColumn; | |
11732 | |
11733 /** | |
11734 * The kind of the element. | |
11735 */ | |
11736 ElementKind get kind => _kind; | |
11737 | |
11738 /** | |
11739 * The kind of the element. | |
11740 */ | |
11741 void set kind(ElementKind value) { | |
11742 assert(value != null); | |
11743 this._kind = value; | |
11744 } | |
11745 | |
11746 /** | |
11747 * The index of the file (in the enclosing navigation response) to navigate | |
11748 * to. | |
11749 */ | |
11750 int get fileIndex => _fileIndex; | |
11751 | |
11752 /** | |
11753 * The index of the file (in the enclosing navigation response) to navigate | |
11754 * to. | |
11755 */ | |
11756 void set fileIndex(int value) { | |
11757 assert(value != null); | |
11758 this._fileIndex = value; | |
11759 } | |
11760 | |
11761 /** | |
11762 * The offset of the region from which the user can navigate. | |
11763 */ | |
11764 int get offset => _offset; | |
11765 | |
11766 /** | |
11767 * The offset of the region from which the user can navigate. | |
11768 */ | |
11769 void set offset(int value) { | |
11770 assert(value != null); | |
11771 this._offset = value; | |
11772 } | |
11773 | |
11774 /** | |
11775 * The length of the region from which the user can navigate. | |
11776 */ | |
11777 int get length => _length; | |
11778 | |
11779 /** | |
11780 * The length of the region from which the user can navigate. | |
11781 */ | |
11782 void set length(int value) { | |
11783 assert(value != null); | |
11784 this._length = value; | |
11785 } | |
11786 | |
11787 /** | |
11788 * The one-based index of the line containing the first character of the | |
11789 * region. | |
11790 */ | |
11791 int get startLine => _startLine; | |
11792 | |
11793 /** | |
11794 * The one-based index of the line containing the first character of the | |
11795 * region. | |
11796 */ | |
11797 void set startLine(int value) { | |
11798 assert(value != null); | |
11799 this._startLine = value; | |
11800 } | |
11801 | |
11802 /** | |
11803 * The one-based index of the column containing the first character of the | |
11804 * region. | |
11805 */ | |
11806 int get startColumn => _startColumn; | |
11807 | |
11808 /** | |
11809 * The one-based index of the column containing the first character of the | |
11810 * region. | |
11811 */ | |
11812 void set startColumn(int value) { | |
11813 assert(value != null); | |
11814 this._startColumn = value; | |
11815 } | |
11816 | |
11817 NavigationTarget(ElementKind kind, int fileIndex, int offset, int length, int
startLine, int startColumn) { | |
11818 this.kind = kind; | |
11819 this.fileIndex = fileIndex; | |
11820 this.offset = offset; | |
11821 this.length = length; | |
11822 this.startLine = startLine; | |
11823 this.startColumn = startColumn; | |
11824 } | |
11825 | |
11826 factory NavigationTarget.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
11827 if (json == null) { | |
11828 json = {}; | |
11829 } | |
11830 if (json is Map) { | |
11831 ElementKind kind; | |
11832 if (json.containsKey("kind")) { | |
11833 kind = new ElementKind.fromJson(jsonDecoder, jsonPath + ".kind", json["k
ind"]); | |
11834 } else { | |
11835 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
11836 } | |
11837 int fileIndex; | |
11838 if (json.containsKey("fileIndex")) { | |
11839 fileIndex = jsonDecoder._decodeInt(jsonPath + ".fileIndex", json["fileIn
dex"]); | |
11840 } else { | |
11841 throw jsonDecoder.missingKey(jsonPath, "fileIndex"); | |
11842 } | |
11843 int offset; | |
11844 if (json.containsKey("offset")) { | |
11845 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
11846 } else { | |
11847 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
11848 } | |
11849 int length; | |
11850 if (json.containsKey("length")) { | |
11851 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
11852 } else { | |
11853 throw jsonDecoder.missingKey(jsonPath, "length"); | |
11854 } | |
11855 int startLine; | |
11856 if (json.containsKey("startLine")) { | |
11857 startLine = jsonDecoder._decodeInt(jsonPath + ".startLine", json["startL
ine"]); | |
11858 } else { | |
11859 throw jsonDecoder.missingKey(jsonPath, "startLine"); | |
11860 } | |
11861 int startColumn; | |
11862 if (json.containsKey("startColumn")) { | |
11863 startColumn = jsonDecoder._decodeInt(jsonPath + ".startColumn", json["st
artColumn"]); | |
11864 } else { | |
11865 throw jsonDecoder.missingKey(jsonPath, "startColumn"); | |
11866 } | |
11867 return new NavigationTarget(kind, fileIndex, offset, length, startLine, st
artColumn); | |
11868 } else { | |
11869 throw jsonDecoder.mismatch(jsonPath, "NavigationTarget", json); | |
11870 } | |
11871 } | |
11872 | |
11873 Map<String, dynamic> toJson() { | |
11874 Map<String, dynamic> result = {}; | |
11875 result["kind"] = kind.toJson(); | |
11876 result["fileIndex"] = fileIndex; | |
11877 result["offset"] = offset; | |
11878 result["length"] = length; | |
11879 result["startLine"] = startLine; | |
11880 result["startColumn"] = startColumn; | |
11881 return result; | |
11882 } | |
11883 | |
11884 @override | |
11885 String toString() => JSON.encode(toJson()); | |
11886 | |
11887 @override | |
11888 bool operator==(other) { | |
11889 if (other is NavigationTarget) { | |
11890 return kind == other.kind && | |
11891 fileIndex == other.fileIndex && | |
11892 offset == other.offset && | |
11893 length == other.length && | |
11894 startLine == other.startLine && | |
11895 startColumn == other.startColumn; | |
11896 } | |
11897 return false; | |
11898 } | |
11899 | |
11900 @override | |
11901 int get hashCode { | |
11902 int hash = 0; | |
11903 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
11904 hash = _JenkinsSmiHash.combine(hash, fileIndex.hashCode); | |
11905 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
11906 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
11907 hash = _JenkinsSmiHash.combine(hash, startLine.hashCode); | |
11908 hash = _JenkinsSmiHash.combine(hash, startColumn.hashCode); | |
11909 return _JenkinsSmiHash.finish(hash); | |
11910 } | |
11911 } | |
11912 | |
11913 /** | |
11914 * Occurrences | |
11915 * | |
11916 * { | |
11917 * "element": Element | |
11918 * "offsets": List<int> | |
11919 * "length": int | |
11920 * } | |
11921 */ | |
11922 class Occurrences implements HasToJson { | |
11923 Element _element; | |
11924 | |
11925 List<int> _offsets; | |
11926 | |
11927 int _length; | |
11928 | |
11929 /** | |
11930 * The element that was referenced. | |
11931 */ | |
11932 Element get element => _element; | |
11933 | |
11934 /** | |
11935 * The element that was referenced. | |
11936 */ | |
11937 void set element(Element value) { | |
11938 assert(value != null); | |
11939 this._element = value; | |
11940 } | |
11941 | |
11942 /** | |
11943 * The offsets of the name of the referenced element within the file. | |
11944 */ | |
11945 List<int> get offsets => _offsets; | |
11946 | |
11947 /** | |
11948 * The offsets of the name of the referenced element within the file. | |
11949 */ | |
11950 void set offsets(List<int> value) { | |
11951 assert(value != null); | |
11952 this._offsets = value; | |
11953 } | |
11954 | |
11955 /** | |
11956 * The length of the name of the referenced element. | |
11957 */ | |
11958 int get length => _length; | |
11959 | |
11960 /** | |
11961 * The length of the name of the referenced element. | |
11962 */ | |
11963 void set length(int value) { | |
11964 assert(value != null); | |
11965 this._length = value; | |
11966 } | |
11967 | |
11968 Occurrences(Element element, List<int> offsets, int length) { | |
11969 this.element = element; | |
11970 this.offsets = offsets; | |
11971 this.length = length; | |
11972 } | |
11973 | |
11974 factory Occurrences.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object
json) { | |
11975 if (json == null) { | |
11976 json = {}; | |
11977 } | |
11978 if (json is Map) { | |
11979 Element element; | |
11980 if (json.containsKey("element")) { | |
11981 element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json[
"element"]); | |
11982 } else { | |
11983 throw jsonDecoder.missingKey(jsonPath, "element"); | |
11984 } | |
11985 List<int> offsets; | |
11986 if (json.containsKey("offsets")) { | |
11987 offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"]
, jsonDecoder._decodeInt); | |
11988 } else { | |
11989 throw jsonDecoder.missingKey(jsonPath, "offsets"); | |
11990 } | |
11991 int length; | |
11992 if (json.containsKey("length")) { | |
11993 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
11994 } else { | |
11995 throw jsonDecoder.missingKey(jsonPath, "length"); | |
11996 } | |
11997 return new Occurrences(element, offsets, length); | |
11998 } else { | |
11999 throw jsonDecoder.mismatch(jsonPath, "Occurrences", json); | |
12000 } | |
12001 } | |
12002 | |
12003 Map<String, dynamic> toJson() { | |
12004 Map<String, dynamic> result = {}; | |
12005 result["element"] = element.toJson(); | |
12006 result["offsets"] = offsets; | |
12007 result["length"] = length; | |
12008 return result; | |
12009 } | |
12010 | |
12011 @override | |
12012 String toString() => JSON.encode(toJson()); | |
12013 | |
12014 @override | |
12015 bool operator==(other) { | |
12016 if (other is Occurrences) { | |
12017 return element == other.element && | |
12018 _listEqual(offsets, other.offsets, (int a, int b) => a == b) && | |
12019 length == other.length; | |
12020 } | |
12021 return false; | |
12022 } | |
12023 | |
12024 @override | |
12025 int get hashCode { | |
12026 int hash = 0; | |
12027 hash = _JenkinsSmiHash.combine(hash, element.hashCode); | |
12028 hash = _JenkinsSmiHash.combine(hash, offsets.hashCode); | |
12029 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
12030 return _JenkinsSmiHash.finish(hash); | |
12031 } | |
12032 } | |
12033 | |
12034 /** | |
12035 * Outline | |
12036 * | |
12037 * { | |
12038 * "element": Element | |
12039 * "offset": int | |
12040 * "length": int | |
12041 * "children": optional List<Outline> | |
12042 * } | |
12043 */ | |
12044 class Outline implements HasToJson { | |
12045 Element _element; | |
12046 | |
12047 int _offset; | |
12048 | |
12049 int _length; | |
12050 | |
12051 List<Outline> _children; | |
12052 | |
12053 /** | |
12054 * A description of the element represented by this node. | |
12055 */ | |
12056 Element get element => _element; | |
12057 | |
12058 /** | |
12059 * A description of the element represented by this node. | |
12060 */ | |
12061 void set element(Element value) { | |
12062 assert(value != null); | |
12063 this._element = value; | |
12064 } | |
12065 | |
12066 /** | |
12067 * The offset of the first character of the element. This is different than | |
12068 * the offset in the Element, which if the offset of the name of the element. | |
12069 * It can be used, for example, to map locations in the file back to an | |
12070 * outline. | |
12071 */ | |
12072 int get offset => _offset; | |
12073 | |
12074 /** | |
12075 * The offset of the first character of the element. This is different than | |
12076 * the offset in the Element, which if the offset of the name of the element. | |
12077 * It can be used, for example, to map locations in the file back to an | |
12078 * outline. | |
12079 */ | |
12080 void set offset(int value) { | |
12081 assert(value != null); | |
12082 this._offset = value; | |
12083 } | |
12084 | |
12085 /** | |
12086 * The length of the element. | |
12087 */ | |
12088 int get length => _length; | |
12089 | |
12090 /** | |
12091 * The length of the element. | |
12092 */ | |
12093 void set length(int value) { | |
12094 assert(value != null); | |
12095 this._length = value; | |
12096 } | |
12097 | |
12098 /** | |
12099 * The children of the node. The field will be omitted if the node has no | |
12100 * children. | |
12101 */ | |
12102 List<Outline> get children => _children; | |
12103 | |
12104 /** | |
12105 * The children of the node. The field will be omitted if the node has no | |
12106 * children. | |
12107 */ | |
12108 void set children(List<Outline> value) { | |
12109 this._children = value; | |
12110 } | |
12111 | |
12112 Outline(Element element, int offset, int length, {List<Outline> children}) { | |
12113 this.element = element; | |
12114 this.offset = offset; | |
12115 this.length = length; | |
12116 this.children = children; | |
12117 } | |
12118 | |
12119 factory Outline.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json
) { | |
12120 if (json == null) { | |
12121 json = {}; | |
12122 } | |
12123 if (json is Map) { | |
12124 Element element; | |
12125 if (json.containsKey("element")) { | |
12126 element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json[
"element"]); | |
12127 } else { | |
12128 throw jsonDecoder.missingKey(jsonPath, "element"); | |
12129 } | |
12130 int offset; | |
12131 if (json.containsKey("offset")) { | |
12132 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
12133 } else { | |
12134 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
12135 } | |
12136 int length; | |
12137 if (json.containsKey("length")) { | |
12138 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
12139 } else { | |
12140 throw jsonDecoder.missingKey(jsonPath, "length"); | |
12141 } | |
12142 List<Outline> children; | |
12143 if (json.containsKey("children")) { | |
12144 children = jsonDecoder._decodeList(jsonPath + ".children", json["childre
n"], (String jsonPath, Object json) => new Outline.fromJson(jsonDecoder, jsonPat
h, json)); | |
12145 } | |
12146 return new Outline(element, offset, length, children: children); | |
12147 } else { | |
12148 throw jsonDecoder.mismatch(jsonPath, "Outline", json); | |
12149 } | |
12150 } | |
12151 | |
12152 Map<String, dynamic> toJson() { | |
12153 Map<String, dynamic> result = {}; | |
12154 result["element"] = element.toJson(); | |
12155 result["offset"] = offset; | |
12156 result["length"] = length; | |
12157 if (children != null) { | |
12158 result["children"] = children.map((Outline value) => value.toJson()).toLis
t(); | |
12159 } | |
12160 return result; | |
12161 } | |
12162 | |
12163 @override | |
12164 String toString() => JSON.encode(toJson()); | |
12165 | |
12166 @override | |
12167 bool operator==(other) { | |
12168 if (other is Outline) { | |
12169 return element == other.element && | |
12170 offset == other.offset && | |
12171 length == other.length && | |
12172 _listEqual(children, other.children, (Outline a, Outline b) => a == b)
; | |
12173 } | |
12174 return false; | |
12175 } | |
12176 | |
12177 @override | |
12178 int get hashCode { | |
12179 int hash = 0; | |
12180 hash = _JenkinsSmiHash.combine(hash, element.hashCode); | |
12181 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
12182 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
12183 hash = _JenkinsSmiHash.combine(hash, children.hashCode); | |
12184 return _JenkinsSmiHash.finish(hash); | |
12185 } | |
12186 } | |
12187 | |
12188 /** | |
12189 * Override | |
12190 * | |
12191 * { | |
12192 * "offset": int | |
12193 * "length": int | |
12194 * "superclassMember": optional OverriddenMember | |
12195 * "interfaceMembers": optional List<OverriddenMember> | |
12196 * } | |
12197 */ | |
12198 class Override implements HasToJson { | |
12199 int _offset; | |
12200 | |
12201 int _length; | |
12202 | |
12203 OverriddenMember _superclassMember; | |
12204 | |
12205 List<OverriddenMember> _interfaceMembers; | |
12206 | |
12207 /** | |
12208 * The offset of the name of the overriding member. | |
12209 */ | |
12210 int get offset => _offset; | |
12211 | |
12212 /** | |
12213 * The offset of the name of the overriding member. | |
12214 */ | |
12215 void set offset(int value) { | |
12216 assert(value != null); | |
12217 this._offset = value; | |
12218 } | |
12219 | |
12220 /** | |
12221 * The length of the name of the overriding member. | |
12222 */ | |
12223 int get length => _length; | |
12224 | |
12225 /** | |
12226 * The length of the name of the overriding member. | |
12227 */ | |
12228 void set length(int value) { | |
12229 assert(value != null); | |
12230 this._length = value; | |
12231 } | |
12232 | |
12233 /** | |
12234 * The member inherited from a superclass that is overridden by the | |
12235 * overriding member. The field is omitted if there is no superclass member, | |
12236 * in which case there must be at least one interface member. | |
12237 */ | |
12238 OverriddenMember get superclassMember => _superclassMember; | |
12239 | |
12240 /** | |
12241 * The member inherited from a superclass that is overridden by the | |
12242 * overriding member. The field is omitted if there is no superclass member, | |
12243 * in which case there must be at least one interface member. | |
12244 */ | |
12245 void set superclassMember(OverriddenMember value) { | |
12246 this._superclassMember = value; | |
12247 } | |
12248 | |
12249 /** | |
12250 * The members inherited from interfaces that are overridden by the | |
12251 * overriding member. The field is omitted if there are no interface members, | |
12252 * in which case there must be a superclass member. | |
12253 */ | |
12254 List<OverriddenMember> get interfaceMembers => _interfaceMembers; | |
12255 | |
12256 /** | |
12257 * The members inherited from interfaces that are overridden by the | |
12258 * overriding member. The field is omitted if there are no interface members, | |
12259 * in which case there must be a superclass member. | |
12260 */ | |
12261 void set interfaceMembers(List<OverriddenMember> value) { | |
12262 this._interfaceMembers = value; | |
12263 } | |
12264 | |
12265 Override(int offset, int length, {OverriddenMember superclassMember, List<Over
riddenMember> interfaceMembers}) { | |
12266 this.offset = offset; | |
12267 this.length = length; | |
12268 this.superclassMember = superclassMember; | |
12269 this.interfaceMembers = interfaceMembers; | |
12270 } | |
12271 | |
12272 factory Override.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object jso
n) { | |
12273 if (json == null) { | |
12274 json = {}; | |
12275 } | |
12276 if (json is Map) { | |
12277 int offset; | |
12278 if (json.containsKey("offset")) { | |
12279 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
12280 } else { | |
12281 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
12282 } | |
12283 int length; | |
12284 if (json.containsKey("length")) { | |
12285 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
12286 } else { | |
12287 throw jsonDecoder.missingKey(jsonPath, "length"); | |
12288 } | |
12289 OverriddenMember superclassMember; | |
12290 if (json.containsKey("superclassMember")) { | |
12291 superclassMember = new OverriddenMember.fromJson(jsonDecoder, jsonPath +
".superclassMember", json["superclassMember"]); | |
12292 } | |
12293 List<OverriddenMember> interfaceMembers; | |
12294 if (json.containsKey("interfaceMembers")) { | |
12295 interfaceMembers = jsonDecoder._decodeList(jsonPath + ".interfaceMembers
", json["interfaceMembers"], (String jsonPath, Object json) => new OverriddenMem
ber.fromJson(jsonDecoder, jsonPath, json)); | |
12296 } | |
12297 return new Override(offset, length, superclassMember: superclassMember, in
terfaceMembers: interfaceMembers); | |
12298 } else { | |
12299 throw jsonDecoder.mismatch(jsonPath, "Override", json); | |
12300 } | |
12301 } | |
12302 | |
12303 Map<String, dynamic> toJson() { | |
12304 Map<String, dynamic> result = {}; | |
12305 result["offset"] = offset; | |
12306 result["length"] = length; | |
12307 if (superclassMember != null) { | |
12308 result["superclassMember"] = superclassMember.toJson(); | |
12309 } | |
12310 if (interfaceMembers != null) { | |
12311 result["interfaceMembers"] = interfaceMembers.map((OverriddenMember value)
=> value.toJson()).toList(); | |
12312 } | |
12313 return result; | |
12314 } | |
12315 | |
12316 @override | |
12317 String toString() => JSON.encode(toJson()); | |
12318 | |
12319 @override | |
12320 bool operator==(other) { | |
12321 if (other is Override) { | |
12322 return offset == other.offset && | |
12323 length == other.length && | |
12324 superclassMember == other.superclassMember && | |
12325 _listEqual(interfaceMembers, other.interfaceMembers, (OverriddenMember
a, OverriddenMember b) => a == b); | |
12326 } | |
12327 return false; | |
12328 } | |
12329 | |
12330 @override | |
12331 int get hashCode { | |
12332 int hash = 0; | |
12333 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
12334 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
12335 hash = _JenkinsSmiHash.combine(hash, superclassMember.hashCode); | |
12336 hash = _JenkinsSmiHash.combine(hash, interfaceMembers.hashCode); | |
12337 return _JenkinsSmiHash.finish(hash); | |
12338 } | |
12339 } | |
12340 | |
12341 /** | |
12342 * OverriddenMember | |
12343 * | |
12344 * { | |
12345 * "element": Element | |
12346 * "className": String | |
12347 * } | |
12348 */ | |
12349 class OverriddenMember implements HasToJson { | |
12350 Element _element; | |
12351 | |
12352 String _className; | |
12353 | |
12354 /** | |
12355 * The element that is being overridden. | |
12356 */ | |
12357 Element get element => _element; | |
12358 | |
12359 /** | |
12360 * The element that is being overridden. | |
12361 */ | |
12362 void set element(Element value) { | |
12363 assert(value != null); | |
12364 this._element = value; | |
12365 } | |
12366 | |
12367 /** | |
12368 * The name of the class in which the member is defined. | |
12369 */ | |
12370 String get className => _className; | |
12371 | |
12372 /** | |
12373 * The name of the class in which the member is defined. | |
12374 */ | |
12375 void set className(String value) { | |
12376 assert(value != null); | |
12377 this._className = value; | |
12378 } | |
12379 | |
12380 OverriddenMember(Element element, String className) { | |
12381 this.element = element; | |
12382 this.className = className; | |
12383 } | |
12384 | |
12385 factory OverriddenMember.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
12386 if (json == null) { | |
12387 json = {}; | |
12388 } | |
12389 if (json is Map) { | |
12390 Element element; | |
12391 if (json.containsKey("element")) { | |
12392 element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json[
"element"]); | |
12393 } else { | |
12394 throw jsonDecoder.missingKey(jsonPath, "element"); | |
12395 } | |
12396 String className; | |
12397 if (json.containsKey("className")) { | |
12398 className = jsonDecoder._decodeString(jsonPath + ".className", json["cla
ssName"]); | |
12399 } else { | |
12400 throw jsonDecoder.missingKey(jsonPath, "className"); | |
12401 } | |
12402 return new OverriddenMember(element, className); | |
12403 } else { | |
12404 throw jsonDecoder.mismatch(jsonPath, "OverriddenMember", json); | |
12405 } | |
12406 } | |
12407 | |
12408 Map<String, dynamic> toJson() { | |
12409 Map<String, dynamic> result = {}; | |
12410 result["element"] = element.toJson(); | |
12411 result["className"] = className; | |
12412 return result; | |
12413 } | |
12414 | |
12415 @override | |
12416 String toString() => JSON.encode(toJson()); | |
12417 | |
12418 @override | |
12419 bool operator==(other) { | |
12420 if (other is OverriddenMember) { | |
12421 return element == other.element && | |
12422 className == other.className; | |
12423 } | |
12424 return false; | |
12425 } | |
12426 | |
12427 @override | |
12428 int get hashCode { | |
12429 int hash = 0; | |
12430 hash = _JenkinsSmiHash.combine(hash, element.hashCode); | |
12431 hash = _JenkinsSmiHash.combine(hash, className.hashCode); | |
12432 return _JenkinsSmiHash.finish(hash); | |
12433 } | |
12434 } | |
12435 | |
12436 /** | |
12437 * Position | |
12438 * | |
12439 * { | |
12440 * "file": FilePath | |
12441 * "offset": int | |
12442 * } | |
12443 */ | |
12444 class Position implements HasToJson { | |
12445 String _file; | |
12446 | |
12447 int _offset; | |
12448 | |
12449 /** | |
12450 * The file containing the position. | |
12451 */ | |
12452 String get file => _file; | |
12453 | |
12454 /** | |
12455 * The file containing the position. | |
12456 */ | |
12457 void set file(String value) { | |
12458 assert(value != null); | |
12459 this._file = value; | |
12460 } | |
12461 | |
12462 /** | |
12463 * The offset of the position. | |
12464 */ | |
12465 int get offset => _offset; | |
12466 | |
12467 /** | |
12468 * The offset of the position. | |
12469 */ | |
12470 void set offset(int value) { | |
12471 assert(value != null); | |
12472 this._offset = value; | |
12473 } | |
12474 | |
12475 Position(String file, int offset) { | |
12476 this.file = file; | |
12477 this.offset = offset; | |
12478 } | |
12479 | |
12480 factory Position.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object jso
n) { | |
12481 if (json == null) { | |
12482 json = {}; | |
12483 } | |
12484 if (json is Map) { | |
12485 String file; | |
12486 if (json.containsKey("file")) { | |
12487 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
12488 } else { | |
12489 throw jsonDecoder.missingKey(jsonPath, "file"); | |
12490 } | |
12491 int offset; | |
12492 if (json.containsKey("offset")) { | |
12493 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
12494 } else { | |
12495 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
12496 } | |
12497 return new Position(file, offset); | |
12498 } else { | |
12499 throw jsonDecoder.mismatch(jsonPath, "Position", json); | |
12500 } | |
12501 } | |
12502 | |
12503 Map<String, dynamic> toJson() { | |
12504 Map<String, dynamic> result = {}; | |
12505 result["file"] = file; | |
12506 result["offset"] = offset; | |
12507 return result; | |
12508 } | |
12509 | |
12510 @override | |
12511 String toString() => JSON.encode(toJson()); | |
12512 | |
12513 @override | |
12514 bool operator==(other) { | |
12515 if (other is Position) { | |
12516 return file == other.file && | |
12517 offset == other.offset; | |
12518 } | |
12519 return false; | |
12520 } | |
12521 | |
12522 @override | |
12523 int get hashCode { | |
12524 int hash = 0; | |
12525 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
12526 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
12527 return _JenkinsSmiHash.finish(hash); | |
12528 } | |
12529 } | |
12530 | |
12531 /** | |
12532 * PubStatus | |
12533 * | |
12534 * { | |
12535 * "isListingPackageDirs": bool | |
12536 * } | |
12537 */ | |
12538 class PubStatus implements HasToJson { | |
12539 bool _isListingPackageDirs; | |
12540 | |
12541 /** | |
12542 * True if the server is currently running pub to produce a list of package | |
12543 * directories. | |
12544 */ | |
12545 bool get isListingPackageDirs => _isListingPackageDirs; | |
12546 | |
12547 /** | |
12548 * True if the server is currently running pub to produce a list of package | |
12549 * directories. | |
12550 */ | |
12551 void set isListingPackageDirs(bool value) { | |
12552 assert(value != null); | |
12553 this._isListingPackageDirs = value; | |
12554 } | |
12555 | |
12556 PubStatus(bool isListingPackageDirs) { | |
12557 this.isListingPackageDirs = isListingPackageDirs; | |
12558 } | |
12559 | |
12560 factory PubStatus.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object js
on) { | |
12561 if (json == null) { | |
12562 json = {}; | |
12563 } | |
12564 if (json is Map) { | |
12565 bool isListingPackageDirs; | |
12566 if (json.containsKey("isListingPackageDirs")) { | |
12567 isListingPackageDirs = jsonDecoder._decodeBool(jsonPath + ".isListingPac
kageDirs", json["isListingPackageDirs"]); | |
12568 } else { | |
12569 throw jsonDecoder.missingKey(jsonPath, "isListingPackageDirs"); | |
12570 } | |
12571 return new PubStatus(isListingPackageDirs); | |
12572 } else { | |
12573 throw jsonDecoder.mismatch(jsonPath, "PubStatus", json); | |
12574 } | |
12575 } | |
12576 | |
12577 Map<String, dynamic> toJson() { | |
12578 Map<String, dynamic> result = {}; | |
12579 result["isListingPackageDirs"] = isListingPackageDirs; | |
12580 return result; | |
12581 } | |
12582 | |
12583 @override | |
12584 String toString() => JSON.encode(toJson()); | |
12585 | |
12586 @override | |
12587 bool operator==(other) { | |
12588 if (other is PubStatus) { | |
12589 return isListingPackageDirs == other.isListingPackageDirs; | |
12590 } | |
12591 return false; | |
12592 } | |
12593 | |
12594 @override | |
12595 int get hashCode { | |
12596 int hash = 0; | |
12597 hash = _JenkinsSmiHash.combine(hash, isListingPackageDirs.hashCode); | |
12598 return _JenkinsSmiHash.finish(hash); | |
12599 } | |
12600 } | |
12601 | |
12602 /** | |
12603 * RefactoringKind | |
12604 * | |
12605 * enum { | |
12606 * CONVERT_GETTER_TO_METHOD | |
12607 * CONVERT_METHOD_TO_GETTER | |
12608 * EXTRACT_LOCAL_VARIABLE | |
12609 * EXTRACT_METHOD | |
12610 * INLINE_LOCAL_VARIABLE | |
12611 * INLINE_METHOD | |
12612 * MOVE_FILE | |
12613 * RENAME | |
12614 * SORT_MEMBERS | |
12615 * } | |
12616 */ | |
12617 class RefactoringKind implements Enum { | |
12618 static const CONVERT_GETTER_TO_METHOD = const RefactoringKind._("CONVERT_GETTE
R_TO_METHOD"); | |
12619 | |
12620 static const CONVERT_METHOD_TO_GETTER = const RefactoringKind._("CONVERT_METHO
D_TO_GETTER"); | |
12621 | |
12622 static const EXTRACT_LOCAL_VARIABLE = const RefactoringKind._("EXTRACT_LOCAL_V
ARIABLE"); | |
12623 | |
12624 static const EXTRACT_METHOD = const RefactoringKind._("EXTRACT_METHOD"); | |
12625 | |
12626 static const INLINE_LOCAL_VARIABLE = const RefactoringKind._("INLINE_LOCAL_VAR
IABLE"); | |
12627 | |
12628 static const INLINE_METHOD = const RefactoringKind._("INLINE_METHOD"); | |
12629 | |
12630 static const MOVE_FILE = const RefactoringKind._("MOVE_FILE"); | |
12631 | |
12632 static const RENAME = const RefactoringKind._("RENAME"); | |
12633 | |
12634 static const SORT_MEMBERS = const RefactoringKind._("SORT_MEMBERS"); | |
12635 | |
12636 /** | |
12637 * A list containing all of the enum values that are defined. | |
12638 */ | |
12639 static const List<RefactoringKind> VALUES = const <RefactoringKind>[CONVERT_GE
TTER_TO_METHOD, CONVERT_METHOD_TO_GETTER, EXTRACT_LOCAL_VARIABLE, EXTRACT_METHOD
, INLINE_LOCAL_VARIABLE, INLINE_METHOD, MOVE_FILE, RENAME, SORT_MEMBERS]; | |
12640 | |
12641 final String name; | |
12642 | |
12643 const RefactoringKind._(this.name); | |
12644 | |
12645 factory RefactoringKind(String name) { | |
12646 switch (name) { | |
12647 case "CONVERT_GETTER_TO_METHOD": | |
12648 return CONVERT_GETTER_TO_METHOD; | |
12649 case "CONVERT_METHOD_TO_GETTER": | |
12650 return CONVERT_METHOD_TO_GETTER; | |
12651 case "EXTRACT_LOCAL_VARIABLE": | |
12652 return EXTRACT_LOCAL_VARIABLE; | |
12653 case "EXTRACT_METHOD": | |
12654 return EXTRACT_METHOD; | |
12655 case "INLINE_LOCAL_VARIABLE": | |
12656 return INLINE_LOCAL_VARIABLE; | |
12657 case "INLINE_METHOD": | |
12658 return INLINE_METHOD; | |
12659 case "MOVE_FILE": | |
12660 return MOVE_FILE; | |
12661 case "RENAME": | |
12662 return RENAME; | |
12663 case "SORT_MEMBERS": | |
12664 return SORT_MEMBERS; | |
12665 } | |
12666 throw new Exception('Illegal enum value: $name'); | |
12667 } | |
12668 | |
12669 factory RefactoringKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obj
ect json) { | |
12670 if (json is String) { | |
12671 try { | |
12672 return new RefactoringKind(json); | |
12673 } catch(_) { | |
12674 // Fall through | |
12675 } | |
12676 } | |
12677 throw jsonDecoder.mismatch(jsonPath, "RefactoringKind", json); | |
12678 } | |
12679 | |
12680 @override | |
12681 String toString() => "RefactoringKind.$name"; | |
12682 | |
12683 String toJson() => name; | |
12684 } | |
12685 | |
12686 /** | |
12687 * RefactoringMethodParameter | |
12688 * | |
12689 * { | |
12690 * "id": optional String | |
12691 * "kind": RefactoringMethodParameterKind | |
12692 * "type": String | |
12693 * "name": String | |
12694 * "parameters": optional String | |
12695 * } | |
12696 */ | |
12697 class RefactoringMethodParameter implements HasToJson { | |
12698 String _id; | |
12699 | |
12700 RefactoringMethodParameterKind _kind; | |
12701 | |
12702 String _type; | |
12703 | |
12704 String _name; | |
12705 | |
12706 String _parameters; | |
12707 | |
12708 /** | |
12709 * The unique identifier of the parameter. Clients may omit this field for | |
12710 * the parameters they want to add. | |
12711 */ | |
12712 String get id => _id; | |
12713 | |
12714 /** | |
12715 * The unique identifier of the parameter. Clients may omit this field for | |
12716 * the parameters they want to add. | |
12717 */ | |
12718 void set id(String value) { | |
12719 this._id = value; | |
12720 } | |
12721 | |
12722 /** | |
12723 * The kind of the parameter. | |
12724 */ | |
12725 RefactoringMethodParameterKind get kind => _kind; | |
12726 | |
12727 /** | |
12728 * The kind of the parameter. | |
12729 */ | |
12730 void set kind(RefactoringMethodParameterKind value) { | |
12731 assert(value != null); | |
12732 this._kind = value; | |
12733 } | |
12734 | |
12735 /** | |
12736 * The type that should be given to the parameter, or the return type of the | |
12737 * parameter's function type. | |
12738 */ | |
12739 String get type => _type; | |
12740 | |
12741 /** | |
12742 * The type that should be given to the parameter, or the return type of the | |
12743 * parameter's function type. | |
12744 */ | |
12745 void set type(String value) { | |
12746 assert(value != null); | |
12747 this._type = value; | |
12748 } | |
12749 | |
12750 /** | |
12751 * The name that should be given to the parameter. | |
12752 */ | |
12753 String get name => _name; | |
12754 | |
12755 /** | |
12756 * The name that should be given to the parameter. | |
12757 */ | |
12758 void set name(String value) { | |
12759 assert(value != null); | |
12760 this._name = value; | |
12761 } | |
12762 | |
12763 /** | |
12764 * The parameter list of the parameter's function type. If the parameter is | |
12765 * not of a function type, this field will not be defined. If the function | |
12766 * type has zero parameters, this field will have a value of "()". | |
12767 */ | |
12768 String get parameters => _parameters; | |
12769 | |
12770 /** | |
12771 * The parameter list of the parameter's function type. If the parameter is | |
12772 * not of a function type, this field will not be defined. If the function | |
12773 * type has zero parameters, this field will have a value of "()". | |
12774 */ | |
12775 void set parameters(String value) { | |
12776 this._parameters = value; | |
12777 } | |
12778 | |
12779 RefactoringMethodParameter(RefactoringMethodParameterKind kind, String type, S
tring name, {String id, String parameters}) { | |
12780 this.id = id; | |
12781 this.kind = kind; | |
12782 this.type = type; | |
12783 this.name = name; | |
12784 this.parameters = parameters; | |
12785 } | |
12786 | |
12787 factory RefactoringMethodParameter.fromJson(JsonDecoder jsonDecoder, String js
onPath, Object json) { | |
12788 if (json == null) { | |
12789 json = {}; | |
12790 } | |
12791 if (json is Map) { | |
12792 String id; | |
12793 if (json.containsKey("id")) { | |
12794 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
12795 } | |
12796 RefactoringMethodParameterKind kind; | |
12797 if (json.containsKey("kind")) { | |
12798 kind = new RefactoringMethodParameterKind.fromJson(jsonDecoder, jsonPath
+ ".kind", json["kind"]); | |
12799 } else { | |
12800 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
12801 } | |
12802 String type; | |
12803 if (json.containsKey("type")) { | |
12804 type = jsonDecoder._decodeString(jsonPath + ".type", json["type"]); | |
12805 } else { | |
12806 throw jsonDecoder.missingKey(jsonPath, "type"); | |
12807 } | |
12808 String name; | |
12809 if (json.containsKey("name")) { | |
12810 name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]); | |
12811 } else { | |
12812 throw jsonDecoder.missingKey(jsonPath, "name"); | |
12813 } | |
12814 String parameters; | |
12815 if (json.containsKey("parameters")) { | |
12816 parameters = jsonDecoder._decodeString(jsonPath + ".parameters", json["p
arameters"]); | |
12817 } | |
12818 return new RefactoringMethodParameter(kind, type, name, id: id, parameters
: parameters); | |
12819 } else { | |
12820 throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameter", json); | |
12821 } | |
12822 } | |
12823 | |
12824 Map<String, dynamic> toJson() { | |
12825 Map<String, dynamic> result = {}; | |
12826 if (id != null) { | |
12827 result["id"] = id; | |
12828 } | |
12829 result["kind"] = kind.toJson(); | |
12830 result["type"] = type; | |
12831 result["name"] = name; | |
12832 if (parameters != null) { | |
12833 result["parameters"] = parameters; | |
12834 } | |
12835 return result; | |
12836 } | |
12837 | |
12838 @override | |
12839 String toString() => JSON.encode(toJson()); | |
12840 | |
12841 @override | |
12842 bool operator==(other) { | |
12843 if (other is RefactoringMethodParameter) { | |
12844 return id == other.id && | |
12845 kind == other.kind && | |
12846 type == other.type && | |
12847 name == other.name && | |
12848 parameters == other.parameters; | |
12849 } | |
12850 return false; | |
12851 } | |
12852 | |
12853 @override | |
12854 int get hashCode { | |
12855 int hash = 0; | |
12856 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
12857 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
12858 hash = _JenkinsSmiHash.combine(hash, type.hashCode); | |
12859 hash = _JenkinsSmiHash.combine(hash, name.hashCode); | |
12860 hash = _JenkinsSmiHash.combine(hash, parameters.hashCode); | |
12861 return _JenkinsSmiHash.finish(hash); | |
12862 } | |
12863 } | |
12864 | |
12865 /** | |
12866 * RefactoringFeedback | |
12867 * | |
12868 * { | |
12869 * } | |
12870 */ | |
12871 class RefactoringFeedback implements HasToJson { | |
12872 RefactoringFeedback(); | |
12873 | |
12874 factory RefactoringFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json, Map responseJson) { | |
12875 return _refactoringFeedbackFromJson(jsonDecoder, jsonPath, json, responseJso
n); | |
12876 } | |
12877 | |
12878 Map<String, dynamic> toJson() { | |
12879 Map<String, dynamic> result = {}; | |
12880 return result; | |
12881 } | |
12882 | |
12883 @override | |
12884 String toString() => JSON.encode(toJson()); | |
12885 | |
12886 @override | |
12887 bool operator==(other) { | |
12888 if (other is RefactoringFeedback) { | |
12889 return true; | |
12890 } | |
12891 return false; | |
12892 } | |
12893 | |
12894 @override | |
12895 int get hashCode { | |
12896 int hash = 0; | |
12897 return _JenkinsSmiHash.finish(hash); | |
12898 } | |
12899 } | |
12900 | |
12901 /** | |
12902 * RefactoringOptions | |
12903 * | |
12904 * { | |
12905 * } | |
12906 */ | |
12907 class RefactoringOptions implements HasToJson { | |
12908 RefactoringOptions(); | |
12909 | |
12910 factory RefactoringOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json, RefactoringKind kind) { | |
12911 return _refactoringOptionsFromJson(jsonDecoder, jsonPath, json, kind); | |
12912 } | |
12913 | |
12914 Map<String, dynamic> toJson() { | |
12915 Map<String, dynamic> result = {}; | |
12916 return result; | |
12917 } | |
12918 | |
12919 @override | |
12920 String toString() => JSON.encode(toJson()); | |
12921 | |
12922 @override | |
12923 bool operator==(other) { | |
12924 if (other is RefactoringOptions) { | |
12925 return true; | |
12926 } | |
12927 return false; | |
12928 } | |
12929 | |
12930 @override | |
12931 int get hashCode { | |
12932 int hash = 0; | |
12933 return _JenkinsSmiHash.finish(hash); | |
12934 } | |
12935 } | |
12936 | |
12937 /** | |
12938 * RefactoringMethodParameterKind | |
12939 * | |
12940 * enum { | |
12941 * REQUIRED | |
12942 * POSITIONAL | |
12943 * NAMED | |
12944 * } | |
12945 */ | |
12946 class RefactoringMethodParameterKind implements Enum { | |
12947 static const REQUIRED = const RefactoringMethodParameterKind._("REQUIRED"); | |
12948 | |
12949 static const POSITIONAL = const RefactoringMethodParameterKind._("POSITIONAL")
; | |
12950 | |
12951 static const NAMED = const RefactoringMethodParameterKind._("NAMED"); | |
12952 | |
12953 /** | |
12954 * A list containing all of the enum values that are defined. | |
12955 */ | |
12956 static const List<RefactoringMethodParameterKind> VALUES = const <RefactoringM
ethodParameterKind>[REQUIRED, POSITIONAL, NAMED]; | |
12957 | |
12958 final String name; | |
12959 | |
12960 const RefactoringMethodParameterKind._(this.name); | |
12961 | |
12962 factory RefactoringMethodParameterKind(String name) { | |
12963 switch (name) { | |
12964 case "REQUIRED": | |
12965 return REQUIRED; | |
12966 case "POSITIONAL": | |
12967 return POSITIONAL; | |
12968 case "NAMED": | |
12969 return NAMED; | |
12970 } | |
12971 throw new Exception('Illegal enum value: $name'); | |
12972 } | |
12973 | |
12974 factory RefactoringMethodParameterKind.fromJson(JsonDecoder jsonDecoder, Strin
g jsonPath, Object json) { | |
12975 if (json is String) { | |
12976 try { | |
12977 return new RefactoringMethodParameterKind(json); | |
12978 } catch(_) { | |
12979 // Fall through | |
12980 } | |
12981 } | |
12982 throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameterKind", json)
; | |
12983 } | |
12984 | |
12985 @override | |
12986 String toString() => "RefactoringMethodParameterKind.$name"; | |
12987 | |
12988 String toJson() => name; | |
12989 } | |
12990 | |
12991 /** | |
12992 * RefactoringProblem | |
12993 * | |
12994 * { | |
12995 * "severity": RefactoringProblemSeverity | |
12996 * "message": String | |
12997 * "location": optional Location | |
12998 * } | |
12999 */ | |
13000 class RefactoringProblem implements HasToJson { | |
13001 RefactoringProblemSeverity _severity; | |
13002 | |
13003 String _message; | |
13004 | |
13005 Location _location; | |
13006 | |
13007 /** | |
13008 * The severity of the problem being represented. | |
13009 */ | |
13010 RefactoringProblemSeverity get severity => _severity; | |
13011 | |
13012 /** | |
13013 * The severity of the problem being represented. | |
13014 */ | |
13015 void set severity(RefactoringProblemSeverity value) { | |
13016 assert(value != null); | |
13017 this._severity = value; | |
13018 } | |
13019 | |
13020 /** | |
13021 * A human-readable description of the problem being represented. | |
13022 */ | |
13023 String get message => _message; | |
13024 | |
13025 /** | |
13026 * A human-readable description of the problem being represented. | |
13027 */ | |
13028 void set message(String value) { | |
13029 assert(value != null); | |
13030 this._message = value; | |
13031 } | |
13032 | |
13033 /** | |
13034 * The location of the problem being represented. This field is omitted | |
13035 * unless there is a specific location associated with the problem (such as a | |
13036 * location where an element being renamed will be shadowed). | |
13037 */ | |
13038 Location get location => _location; | |
13039 | |
13040 /** | |
13041 * The location of the problem being represented. This field is omitted | |
13042 * unless there is a specific location associated with the problem (such as a | |
13043 * location where an element being renamed will be shadowed). | |
13044 */ | |
13045 void set location(Location value) { | |
13046 this._location = value; | |
13047 } | |
13048 | |
13049 RefactoringProblem(RefactoringProblemSeverity severity, String message, {Locat
ion location}) { | |
13050 this.severity = severity; | |
13051 this.message = message; | |
13052 this.location = location; | |
13053 } | |
13054 | |
13055 factory RefactoringProblem.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json) { | |
13056 if (json == null) { | |
13057 json = {}; | |
13058 } | |
13059 if (json is Map) { | |
13060 RefactoringProblemSeverity severity; | |
13061 if (json.containsKey("severity")) { | |
13062 severity = new RefactoringProblemSeverity.fromJson(jsonDecoder, jsonPath
+ ".severity", json["severity"]); | |
13063 } else { | |
13064 throw jsonDecoder.missingKey(jsonPath, "severity"); | |
13065 } | |
13066 String message; | |
13067 if (json.containsKey("message")) { | |
13068 message = jsonDecoder._decodeString(jsonPath + ".message", json["message
"]); | |
13069 } else { | |
13070 throw jsonDecoder.missingKey(jsonPath, "message"); | |
13071 } | |
13072 Location location; | |
13073 if (json.containsKey("location")) { | |
13074 location = new Location.fromJson(jsonDecoder, jsonPath + ".location", js
on["location"]); | |
13075 } | |
13076 return new RefactoringProblem(severity, message, location: location); | |
13077 } else { | |
13078 throw jsonDecoder.mismatch(jsonPath, "RefactoringProblem", json); | |
13079 } | |
13080 } | |
13081 | |
13082 Map<String, dynamic> toJson() { | |
13083 Map<String, dynamic> result = {}; | |
13084 result["severity"] = severity.toJson(); | |
13085 result["message"] = message; | |
13086 if (location != null) { | |
13087 result["location"] = location.toJson(); | |
13088 } | |
13089 return result; | |
13090 } | |
13091 | |
13092 @override | |
13093 String toString() => JSON.encode(toJson()); | |
13094 | |
13095 @override | |
13096 bool operator==(other) { | |
13097 if (other is RefactoringProblem) { | |
13098 return severity == other.severity && | |
13099 message == other.message && | |
13100 location == other.location; | |
13101 } | |
13102 return false; | |
13103 } | |
13104 | |
13105 @override | |
13106 int get hashCode { | |
13107 int hash = 0; | |
13108 hash = _JenkinsSmiHash.combine(hash, severity.hashCode); | |
13109 hash = _JenkinsSmiHash.combine(hash, message.hashCode); | |
13110 hash = _JenkinsSmiHash.combine(hash, location.hashCode); | |
13111 return _JenkinsSmiHash.finish(hash); | |
13112 } | |
13113 } | |
13114 | |
13115 /** | |
13116 * RefactoringProblemSeverity | |
13117 * | |
13118 * enum { | |
13119 * INFO | |
13120 * WARNING | |
13121 * ERROR | |
13122 * FATAL | |
13123 * } | |
13124 */ | |
13125 class RefactoringProblemSeverity implements Enum { | |
13126 static const INFO = const RefactoringProblemSeverity._("INFO"); | |
13127 | |
13128 static const WARNING = const RefactoringProblemSeverity._("WARNING"); | |
13129 | |
13130 static const ERROR = const RefactoringProblemSeverity._("ERROR"); | |
13131 | |
13132 static const FATAL = const RefactoringProblemSeverity._("FATAL"); | |
13133 | |
13134 /** | |
13135 * A list containing all of the enum values that are defined. | |
13136 */ | |
13137 static const List<RefactoringProblemSeverity> VALUES = const <RefactoringProbl
emSeverity>[INFO, WARNING, ERROR, FATAL]; | |
13138 | |
13139 final String name; | |
13140 | |
13141 const RefactoringProblemSeverity._(this.name); | |
13142 | |
13143 factory RefactoringProblemSeverity(String name) { | |
13144 switch (name) { | |
13145 case "INFO": | |
13146 return INFO; | |
13147 case "WARNING": | |
13148 return WARNING; | |
13149 case "ERROR": | |
13150 return ERROR; | |
13151 case "FATAL": | |
13152 return FATAL; | |
13153 } | |
13154 throw new Exception('Illegal enum value: $name'); | |
13155 } | |
13156 | |
13157 factory RefactoringProblemSeverity.fromJson(JsonDecoder jsonDecoder, String js
onPath, Object json) { | |
13158 if (json is String) { | |
13159 try { | |
13160 return new RefactoringProblemSeverity(json); | |
13161 } catch(_) { | |
13162 // Fall through | |
13163 } | |
13164 } | |
13165 throw jsonDecoder.mismatch(jsonPath, "RefactoringProblemSeverity", json); | |
13166 } | |
13167 | |
13168 /** | |
13169 * Returns the [RefactoringProblemSeverity] with the maximal severity. | |
13170 */ | |
13171 static RefactoringProblemSeverity max(RefactoringProblemSeverity a, Refactorin
gProblemSeverity b) => | |
13172 _maxRefactoringProblemSeverity(a, b); | |
13173 | |
13174 @override | |
13175 String toString() => "RefactoringProblemSeverity.$name"; | |
13176 | |
13177 String toJson() => name; | |
13178 } | |
13179 | |
13180 /** | |
13181 * RemoveContentOverlay | |
13182 * | |
13183 * { | |
13184 * "type": "remove" | |
13185 * } | |
13186 */ | |
13187 class RemoveContentOverlay implements HasToJson { | |
13188 RemoveContentOverlay(); | |
13189 | |
13190 factory RemoveContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath
, Object json) { | |
13191 if (json == null) { | |
13192 json = {}; | |
13193 } | |
13194 if (json is Map) { | |
13195 if (json["type"] != "remove") { | |
13196 throw jsonDecoder.mismatch(jsonPath, "equal " + "remove", json); | |
13197 } | |
13198 return new RemoveContentOverlay(); | |
13199 } else { | |
13200 throw jsonDecoder.mismatch(jsonPath, "RemoveContentOverlay", json); | |
13201 } | |
13202 } | |
13203 | |
13204 Map<String, dynamic> toJson() { | |
13205 Map<String, dynamic> result = {}; | |
13206 result["type"] = "remove"; | |
13207 return result; | |
13208 } | |
13209 | |
13210 @override | |
13211 String toString() => JSON.encode(toJson()); | |
13212 | |
13213 @override | |
13214 bool operator==(other) { | |
13215 if (other is RemoveContentOverlay) { | |
13216 return true; | |
13217 } | |
13218 return false; | |
13219 } | |
13220 | |
13221 @override | |
13222 int get hashCode { | |
13223 int hash = 0; | |
13224 hash = _JenkinsSmiHash.combine(hash, 114870849); | |
13225 return _JenkinsSmiHash.finish(hash); | |
13226 } | |
13227 } | |
13228 | |
13229 /** | |
13230 * RequestError | |
13231 * | |
13232 * { | |
13233 * "code": RequestErrorCode | |
13234 * "message": String | |
13235 * "stackTrace": optional String | |
13236 * } | |
13237 */ | |
13238 class RequestError implements HasToJson { | |
13239 RequestErrorCode _code; | |
13240 | |
13241 String _message; | |
13242 | |
13243 String _stackTrace; | |
13244 | |
13245 /** | |
13246 * A code that uniquely identifies the error that occurred. | |
13247 */ | |
13248 RequestErrorCode get code => _code; | |
13249 | |
13250 /** | |
13251 * A code that uniquely identifies the error that occurred. | |
13252 */ | |
13253 void set code(RequestErrorCode value) { | |
13254 assert(value != null); | |
13255 this._code = value; | |
13256 } | |
13257 | |
13258 /** | |
13259 * A short description of the error. | |
13260 */ | |
13261 String get message => _message; | |
13262 | |
13263 /** | |
13264 * A short description of the error. | |
13265 */ | |
13266 void set message(String value) { | |
13267 assert(value != null); | |
13268 this._message = value; | |
13269 } | |
13270 | |
13271 /** | |
13272 * The stack trace associated with processing the request, used for debugging | |
13273 * the server. | |
13274 */ | |
13275 String get stackTrace => _stackTrace; | |
13276 | |
13277 /** | |
13278 * The stack trace associated with processing the request, used for debugging | |
13279 * the server. | |
13280 */ | |
13281 void set stackTrace(String value) { | |
13282 this._stackTrace = value; | |
13283 } | |
13284 | |
13285 RequestError(RequestErrorCode code, String message, {String stackTrace}) { | |
13286 this.code = code; | |
13287 this.message = message; | |
13288 this.stackTrace = stackTrace; | |
13289 } | |
13290 | |
13291 factory RequestError.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object
json) { | |
13292 if (json == null) { | |
13293 json = {}; | |
13294 } | |
13295 if (json is Map) { | |
13296 RequestErrorCode code; | |
13297 if (json.containsKey("code")) { | |
13298 code = new RequestErrorCode.fromJson(jsonDecoder, jsonPath + ".code", js
on["code"]); | |
13299 } else { | |
13300 throw jsonDecoder.missingKey(jsonPath, "code"); | |
13301 } | |
13302 String message; | |
13303 if (json.containsKey("message")) { | |
13304 message = jsonDecoder._decodeString(jsonPath + ".message", json["message
"]); | |
13305 } else { | |
13306 throw jsonDecoder.missingKey(jsonPath, "message"); | |
13307 } | |
13308 String stackTrace; | |
13309 if (json.containsKey("stackTrace")) { | |
13310 stackTrace = jsonDecoder._decodeString(jsonPath + ".stackTrace", json["s
tackTrace"]); | |
13311 } | |
13312 return new RequestError(code, message, stackTrace: stackTrace); | |
13313 } else { | |
13314 throw jsonDecoder.mismatch(jsonPath, "RequestError", json); | |
13315 } | |
13316 } | |
13317 | |
13318 Map<String, dynamic> toJson() { | |
13319 Map<String, dynamic> result = {}; | |
13320 result["code"] = code.toJson(); | |
13321 result["message"] = message; | |
13322 if (stackTrace != null) { | |
13323 result["stackTrace"] = stackTrace; | |
13324 } | |
13325 return result; | |
13326 } | |
13327 | |
13328 @override | |
13329 String toString() => JSON.encode(toJson()); | |
13330 | |
13331 @override | |
13332 bool operator==(other) { | |
13333 if (other is RequestError) { | |
13334 return code == other.code && | |
13335 message == other.message && | |
13336 stackTrace == other.stackTrace; | |
13337 } | |
13338 return false; | |
13339 } | |
13340 | |
13341 @override | |
13342 int get hashCode { | |
13343 int hash = 0; | |
13344 hash = _JenkinsSmiHash.combine(hash, code.hashCode); | |
13345 hash = _JenkinsSmiHash.combine(hash, message.hashCode); | |
13346 hash = _JenkinsSmiHash.combine(hash, stackTrace.hashCode); | |
13347 return _JenkinsSmiHash.finish(hash); | |
13348 } | |
13349 } | |
13350 | |
13351 /** | |
13352 * RequestErrorCode | |
13353 * | |
13354 * enum { | |
13355 * CONTENT_MODIFIED | |
13356 * FILE_NOT_ANALYZED | |
13357 * FORMAT_INVALID_FILE | |
13358 * FORMAT_WITH_ERRORS | |
13359 * GET_ERRORS_INVALID_FILE | |
13360 * GET_NAVIGATION_INVALID_FILE | |
13361 * INVALID_ANALYSIS_ROOT | |
13362 * INVALID_EXECUTION_CONTEXT | |
13363 * INVALID_OVERLAY_CHANGE | |
13364 * INVALID_PARAMETER | |
13365 * INVALID_REQUEST | |
13366 * NO_INDEX_GENERATED | |
13367 * ORGANIZE_DIRECTIVES_ERROR | |
13368 * REFACTORING_REQUEST_CANCELLED | |
13369 * SERVER_ALREADY_STARTED | |
13370 * SERVER_ERROR | |
13371 * SORT_MEMBERS_INVALID_FILE | |
13372 * SORT_MEMBERS_PARSE_ERRORS | |
13373 * UNANALYZED_PRIORITY_FILES | |
13374 * UNKNOWN_REQUEST | |
13375 * UNKNOWN_SOURCE | |
13376 * UNSUPPORTED_FEATURE | |
13377 * } | |
13378 */ | |
13379 class RequestErrorCode implements Enum { | |
13380 /** | |
13381 * An "analysis.getErrors" or "analysis.getNavigation" request could not be | |
13382 * satisfied because the content of the file changed before the requested | |
13383 * results could be computed. | |
13384 */ | |
13385 static const CONTENT_MODIFIED = const RequestErrorCode._("CONTENT_MODIFIED"); | |
13386 | |
13387 /** | |
13388 * A request specified a FilePath which does not match a file in an analysis | |
13389 * root, or the requested operation is not available for the file. | |
13390 */ | |
13391 static const FILE_NOT_ANALYZED = const RequestErrorCode._("FILE_NOT_ANALYZED")
; | |
13392 | |
13393 /** | |
13394 * An "edit.format" request specified a FilePath which does not match a Dart | |
13395 * file in an analysis root. | |
13396 */ | |
13397 static const FORMAT_INVALID_FILE = const RequestErrorCode._("FORMAT_INVALID_FI
LE"); | |
13398 | |
13399 /** | |
13400 * An "edit.format" request specified a file that contains syntax errors. | |
13401 */ | |
13402 static const FORMAT_WITH_ERRORS = const RequestErrorCode._("FORMAT_WITH_ERRORS
"); | |
13403 | |
13404 /** | |
13405 * An "analysis.getErrors" request specified a FilePath which does not match | |
13406 * a file currently subject to analysis. | |
13407 */ | |
13408 static const GET_ERRORS_INVALID_FILE = const RequestErrorCode._("GET_ERRORS_IN
VALID_FILE"); | |
13409 | |
13410 /** | |
13411 * An "analysis.getNavigation" request specified a FilePath which does not | |
13412 * match a file currently subject to analysis. | |
13413 */ | |
13414 static const GET_NAVIGATION_INVALID_FILE = const RequestErrorCode._("GET_NAVIG
ATION_INVALID_FILE"); | |
13415 | |
13416 /** | |
13417 * A path passed as an argument to a request (such as analysis.reanalyze) is | |
13418 * required to be an analysis root, but isn't. | |
13419 */ | |
13420 static const INVALID_ANALYSIS_ROOT = const RequestErrorCode._("INVALID_ANALYSI
S_ROOT"); | |
13421 | |
13422 /** | |
13423 * The context root used to create an execution context does not exist. | |
13424 */ | |
13425 static const INVALID_EXECUTION_CONTEXT = const RequestErrorCode._("INVALID_EXE
CUTION_CONTEXT"); | |
13426 | |
13427 /** | |
13428 * An "analysis.updateContent" request contained a ChangeContentOverlay | |
13429 * object which can't be applied, due to an edit having an offset or length | |
13430 * that is out of range. | |
13431 */ | |
13432 static const INVALID_OVERLAY_CHANGE = const RequestErrorCode._("INVALID_OVERLA
Y_CHANGE"); | |
13433 | |
13434 /** | |
13435 * One of the method parameters was invalid. | |
13436 */ | |
13437 static const INVALID_PARAMETER = const RequestErrorCode._("INVALID_PARAMETER")
; | |
13438 | |
13439 /** | |
13440 * A malformed request was received. | |
13441 */ | |
13442 static const INVALID_REQUEST = const RequestErrorCode._("INVALID_REQUEST"); | |
13443 | |
13444 /** | |
13445 * The "--no-index" flag was passed when the analysis server created, but | |
13446 * this API call requires an index to have been generated. | |
13447 */ | |
13448 static const NO_INDEX_GENERATED = const RequestErrorCode._("NO_INDEX_GENERATED
"); | |
13449 | |
13450 /** | |
13451 * An "edit.organizeDirectives" request specified a Dart file that cannot be | |
13452 * analyzed. The reason is described in the message. | |
13453 */ | |
13454 static const ORGANIZE_DIRECTIVES_ERROR = const RequestErrorCode._("ORGANIZE_DI
RECTIVES_ERROR"); | |
13455 | |
13456 /** | |
13457 * Another refactoring request was received during processing of this one. | |
13458 */ | |
13459 static const REFACTORING_REQUEST_CANCELLED = const RequestErrorCode._("REFACTO
RING_REQUEST_CANCELLED"); | |
13460 | |
13461 /** | |
13462 * The analysis server has already been started (and hence won't accept new | |
13463 * connections). | |
13464 * | |
13465 * This error is included for future expansion; at present the analysis | |
13466 * server can only speak to one client at a time so this error will never | |
13467 * occur. | |
13468 */ | |
13469 static const SERVER_ALREADY_STARTED = const RequestErrorCode._("SERVER_ALREADY
_STARTED"); | |
13470 | |
13471 /** | |
13472 * An internal error occurred in the analysis server. Also see the | |
13473 * server.error notification. | |
13474 */ | |
13475 static const SERVER_ERROR = const RequestErrorCode._("SERVER_ERROR"); | |
13476 | |
13477 /** | |
13478 * An "edit.sortMembers" request specified a FilePath which does not match a | |
13479 * Dart file in an analysis root. | |
13480 */ | |
13481 static const SORT_MEMBERS_INVALID_FILE = const RequestErrorCode._("SORT_MEMBER
S_INVALID_FILE"); | |
13482 | |
13483 /** | |
13484 * An "edit.sortMembers" request specified a Dart file that has scan or parse | |
13485 * errors. | |
13486 */ | |
13487 static const SORT_MEMBERS_PARSE_ERRORS = const RequestErrorCode._("SORT_MEMBER
S_PARSE_ERRORS"); | |
13488 | |
13489 /** | |
13490 * An "analysis.setPriorityFiles" request includes one or more files that are | |
13491 * not being analyzed. | |
13492 * | |
13493 * This is a legacy error; it will be removed before the API reaches version | |
13494 * 1.0. | |
13495 */ | |
13496 static const UNANALYZED_PRIORITY_FILES = const RequestErrorCode._("UNANALYZED_
PRIORITY_FILES"); | |
13497 | |
13498 /** | |
13499 * A request was received which the analysis server does not recognize, or | |
13500 * cannot handle in its current configuation. | |
13501 */ | |
13502 static const UNKNOWN_REQUEST = const RequestErrorCode._("UNKNOWN_REQUEST"); | |
13503 | |
13504 /** | |
13505 * The analysis server was requested to perform an action on a source that | |
13506 * does not exist. | |
13507 */ | |
13508 static const UNKNOWN_SOURCE = const RequestErrorCode._("UNKNOWN_SOURCE"); | |
13509 | |
13510 /** | |
13511 * The analysis server was requested to perform an action which is not | |
13512 * supported. | |
13513 * | |
13514 * This is a legacy error; it will be removed before the API reaches version | |
13515 * 1.0. | |
13516 */ | |
13517 static const UNSUPPORTED_FEATURE = const RequestErrorCode._("UNSUPPORTED_FEATU
RE"); | |
13518 | |
13519 /** | |
13520 * A list containing all of the enum values that are defined. | |
13521 */ | |
13522 static const List<RequestErrorCode> VALUES = const <RequestErrorCode>[CONTENT_
MODIFIED, FILE_NOT_ANALYZED, FORMAT_INVALID_FILE, FORMAT_WITH_ERRORS, GET_ERRORS
_INVALID_FILE, GET_NAVIGATION_INVALID_FILE, INVALID_ANALYSIS_ROOT, INVALID_EXECU
TION_CONTEXT, INVALID_OVERLAY_CHANGE, INVALID_PARAMETER, INVALID_REQUEST, NO_IND
EX_GENERATED, ORGANIZE_DIRECTIVES_ERROR, REFACTORING_REQUEST_CANCELLED, SERVER_A
LREADY_STARTED, SERVER_ERROR, SORT_MEMBERS_INVALID_FILE, SORT_MEMBERS_PARSE_ERRO
RS, UNANALYZED_PRIORITY_FILES, UNKNOWN_REQUEST, UNKNOWN_SOURCE, UNSUPPORTED_FEAT
URE]; | |
13523 | |
13524 final String name; | |
13525 | |
13526 const RequestErrorCode._(this.name); | |
13527 | |
13528 factory RequestErrorCode(String name) { | |
13529 switch (name) { | |
13530 case "CONTENT_MODIFIED": | |
13531 return CONTENT_MODIFIED; | |
13532 case "FILE_NOT_ANALYZED": | |
13533 return FILE_NOT_ANALYZED; | |
13534 case "FORMAT_INVALID_FILE": | |
13535 return FORMAT_INVALID_FILE; | |
13536 case "FORMAT_WITH_ERRORS": | |
13537 return FORMAT_WITH_ERRORS; | |
13538 case "GET_ERRORS_INVALID_FILE": | |
13539 return GET_ERRORS_INVALID_FILE; | |
13540 case "GET_NAVIGATION_INVALID_FILE": | |
13541 return GET_NAVIGATION_INVALID_FILE; | |
13542 case "INVALID_ANALYSIS_ROOT": | |
13543 return INVALID_ANALYSIS_ROOT; | |
13544 case "INVALID_EXECUTION_CONTEXT": | |
13545 return INVALID_EXECUTION_CONTEXT; | |
13546 case "INVALID_OVERLAY_CHANGE": | |
13547 return INVALID_OVERLAY_CHANGE; | |
13548 case "INVALID_PARAMETER": | |
13549 return INVALID_PARAMETER; | |
13550 case "INVALID_REQUEST": | |
13551 return INVALID_REQUEST; | |
13552 case "NO_INDEX_GENERATED": | |
13553 return NO_INDEX_GENERATED; | |
13554 case "ORGANIZE_DIRECTIVES_ERROR": | |
13555 return ORGANIZE_DIRECTIVES_ERROR; | |
13556 case "REFACTORING_REQUEST_CANCELLED": | |
13557 return REFACTORING_REQUEST_CANCELLED; | |
13558 case "SERVER_ALREADY_STARTED": | |
13559 return SERVER_ALREADY_STARTED; | |
13560 case "SERVER_ERROR": | |
13561 return SERVER_ERROR; | |
13562 case "SORT_MEMBERS_INVALID_FILE": | |
13563 return SORT_MEMBERS_INVALID_FILE; | |
13564 case "SORT_MEMBERS_PARSE_ERRORS": | |
13565 return SORT_MEMBERS_PARSE_ERRORS; | |
13566 case "UNANALYZED_PRIORITY_FILES": | |
13567 return UNANALYZED_PRIORITY_FILES; | |
13568 case "UNKNOWN_REQUEST": | |
13569 return UNKNOWN_REQUEST; | |
13570 case "UNKNOWN_SOURCE": | |
13571 return UNKNOWN_SOURCE; | |
13572 case "UNSUPPORTED_FEATURE": | |
13573 return UNSUPPORTED_FEATURE; | |
13574 } | |
13575 throw new Exception('Illegal enum value: $name'); | |
13576 } | |
13577 | |
13578 factory RequestErrorCode.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
13579 if (json is String) { | |
13580 try { | |
13581 return new RequestErrorCode(json); | |
13582 } catch(_) { | |
13583 // Fall through | |
13584 } | |
13585 } | |
13586 throw jsonDecoder.mismatch(jsonPath, "RequestErrorCode", json); | |
13587 } | |
13588 | |
13589 @override | |
13590 String toString() => "RequestErrorCode.$name"; | |
13591 | |
13592 String toJson() => name; | |
13593 } | |
13594 | |
13595 /** | |
13596 * SearchResult | |
13597 * | |
13598 * { | |
13599 * "location": Location | |
13600 * "kind": SearchResultKind | |
13601 * "isPotential": bool | |
13602 * "path": List<Element> | |
13603 * } | |
13604 */ | |
13605 class SearchResult implements HasToJson { | |
13606 Location _location; | |
13607 | |
13608 SearchResultKind _kind; | |
13609 | |
13610 bool _isPotential; | |
13611 | |
13612 List<Element> _path; | |
13613 | |
13614 /** | |
13615 * The location of the code that matched the search criteria. | |
13616 */ | |
13617 Location get location => _location; | |
13618 | |
13619 /** | |
13620 * The location of the code that matched the search criteria. | |
13621 */ | |
13622 void set location(Location value) { | |
13623 assert(value != null); | |
13624 this._location = value; | |
13625 } | |
13626 | |
13627 /** | |
13628 * The kind of element that was found or the kind of reference that was | |
13629 * found. | |
13630 */ | |
13631 SearchResultKind get kind => _kind; | |
13632 | |
13633 /** | |
13634 * The kind of element that was found or the kind of reference that was | |
13635 * found. | |
13636 */ | |
13637 void set kind(SearchResultKind value) { | |
13638 assert(value != null); | |
13639 this._kind = value; | |
13640 } | |
13641 | |
13642 /** | |
13643 * True if the result is a potential match but cannot be confirmed to be a | |
13644 * match. For example, if all references to a method m defined in some class | |
13645 * were requested, and a reference to a method m from an unknown class were | |
13646 * found, it would be marked as being a potential match. | |
13647 */ | |
13648 bool get isPotential => _isPotential; | |
13649 | |
13650 /** | |
13651 * True if the result is a potential match but cannot be confirmed to be a | |
13652 * match. For example, if all references to a method m defined in some class | |
13653 * were requested, and a reference to a method m from an unknown class were | |
13654 * found, it would be marked as being a potential match. | |
13655 */ | |
13656 void set isPotential(bool value) { | |
13657 assert(value != null); | |
13658 this._isPotential = value; | |
13659 } | |
13660 | |
13661 /** | |
13662 * The elements that contain the result, starting with the most immediately | |
13663 * enclosing ancestor and ending with the library. | |
13664 */ | |
13665 List<Element> get path => _path; | |
13666 | |
13667 /** | |
13668 * The elements that contain the result, starting with the most immediately | |
13669 * enclosing ancestor and ending with the library. | |
13670 */ | |
13671 void set path(List<Element> value) { | |
13672 assert(value != null); | |
13673 this._path = value; | |
13674 } | |
13675 | |
13676 SearchResult(Location location, SearchResultKind kind, bool isPotential, List<
Element> path) { | |
13677 this.location = location; | |
13678 this.kind = kind; | |
13679 this.isPotential = isPotential; | |
13680 this.path = path; | |
13681 } | |
13682 | |
13683 factory SearchResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object
json) { | |
13684 if (json == null) { | |
13685 json = {}; | |
13686 } | |
13687 if (json is Map) { | |
13688 Location location; | |
13689 if (json.containsKey("location")) { | |
13690 location = new Location.fromJson(jsonDecoder, jsonPath + ".location", js
on["location"]); | |
13691 } else { | |
13692 throw jsonDecoder.missingKey(jsonPath, "location"); | |
13693 } | |
13694 SearchResultKind kind; | |
13695 if (json.containsKey("kind")) { | |
13696 kind = new SearchResultKind.fromJson(jsonDecoder, jsonPath + ".kind", js
on["kind"]); | |
13697 } else { | |
13698 throw jsonDecoder.missingKey(jsonPath, "kind"); | |
13699 } | |
13700 bool isPotential; | |
13701 if (json.containsKey("isPotential")) { | |
13702 isPotential = jsonDecoder._decodeBool(jsonPath + ".isPotential", json["i
sPotential"]); | |
13703 } else { | |
13704 throw jsonDecoder.missingKey(jsonPath, "isPotential"); | |
13705 } | |
13706 List<Element> path; | |
13707 if (json.containsKey("path")) { | |
13708 path = jsonDecoder._decodeList(jsonPath + ".path", json["path"], (String
jsonPath, Object json) => new Element.fromJson(jsonDecoder, jsonPath, json)); | |
13709 } else { | |
13710 throw jsonDecoder.missingKey(jsonPath, "path"); | |
13711 } | |
13712 return new SearchResult(location, kind, isPotential, path); | |
13713 } else { | |
13714 throw jsonDecoder.mismatch(jsonPath, "SearchResult", json); | |
13715 } | |
13716 } | |
13717 | |
13718 Map<String, dynamic> toJson() { | |
13719 Map<String, dynamic> result = {}; | |
13720 result["location"] = location.toJson(); | |
13721 result["kind"] = kind.toJson(); | |
13722 result["isPotential"] = isPotential; | |
13723 result["path"] = path.map((Element value) => value.toJson()).toList(); | |
13724 return result; | |
13725 } | |
13726 | |
13727 @override | |
13728 String toString() => JSON.encode(toJson()); | |
13729 | |
13730 @override | |
13731 bool operator==(other) { | |
13732 if (other is SearchResult) { | |
13733 return location == other.location && | |
13734 kind == other.kind && | |
13735 isPotential == other.isPotential && | |
13736 _listEqual(path, other.path, (Element a, Element b) => a == b); | |
13737 } | |
13738 return false; | |
13739 } | |
13740 | |
13741 @override | |
13742 int get hashCode { | |
13743 int hash = 0; | |
13744 hash = _JenkinsSmiHash.combine(hash, location.hashCode); | |
13745 hash = _JenkinsSmiHash.combine(hash, kind.hashCode); | |
13746 hash = _JenkinsSmiHash.combine(hash, isPotential.hashCode); | |
13747 hash = _JenkinsSmiHash.combine(hash, path.hashCode); | |
13748 return _JenkinsSmiHash.finish(hash); | |
13749 } | |
13750 } | |
13751 | |
13752 /** | |
13753 * SearchResultKind | |
13754 * | |
13755 * enum { | |
13756 * DECLARATION | |
13757 * INVOCATION | |
13758 * READ | |
13759 * READ_WRITE | |
13760 * REFERENCE | |
13761 * UNKNOWN | |
13762 * WRITE | |
13763 * } | |
13764 */ | |
13765 class SearchResultKind implements Enum { | |
13766 /** | |
13767 * The declaration of an element. | |
13768 */ | |
13769 static const DECLARATION = const SearchResultKind._("DECLARATION"); | |
13770 | |
13771 /** | |
13772 * The invocation of a function or method. | |
13773 */ | |
13774 static const INVOCATION = const SearchResultKind._("INVOCATION"); | |
13775 | |
13776 /** | |
13777 * A reference to a field, parameter or variable where it is being read. | |
13778 */ | |
13779 static const READ = const SearchResultKind._("READ"); | |
13780 | |
13781 /** | |
13782 * A reference to a field, parameter or variable where it is being read and | |
13783 * written. | |
13784 */ | |
13785 static const READ_WRITE = const SearchResultKind._("READ_WRITE"); | |
13786 | |
13787 /** | |
13788 * A reference to an element. | |
13789 */ | |
13790 static const REFERENCE = const SearchResultKind._("REFERENCE"); | |
13791 | |
13792 /** | |
13793 * Some other kind of search result. | |
13794 */ | |
13795 static const UNKNOWN = const SearchResultKind._("UNKNOWN"); | |
13796 | |
13797 /** | |
13798 * A reference to a field, parameter or variable where it is being written. | |
13799 */ | |
13800 static const WRITE = const SearchResultKind._("WRITE"); | |
13801 | |
13802 /** | |
13803 * A list containing all of the enum values that are defined. | |
13804 */ | |
13805 static const List<SearchResultKind> VALUES = const <SearchResultKind>[DECLARAT
ION, INVOCATION, READ, READ_WRITE, REFERENCE, UNKNOWN, WRITE]; | |
13806 | |
13807 final String name; | |
13808 | |
13809 const SearchResultKind._(this.name); | |
13810 | |
13811 factory SearchResultKind(String name) { | |
13812 switch (name) { | |
13813 case "DECLARATION": | |
13814 return DECLARATION; | |
13815 case "INVOCATION": | |
13816 return INVOCATION; | |
13817 case "READ": | |
13818 return READ; | |
13819 case "READ_WRITE": | |
13820 return READ_WRITE; | |
13821 case "REFERENCE": | |
13822 return REFERENCE; | |
13823 case "UNKNOWN": | |
13824 return UNKNOWN; | |
13825 case "WRITE": | |
13826 return WRITE; | |
13827 } | |
13828 throw new Exception('Illegal enum value: $name'); | |
13829 } | |
13830 | |
13831 factory SearchResultKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob
ject json) { | |
13832 if (json is String) { | |
13833 try { | |
13834 return new SearchResultKind(json); | |
13835 } catch(_) { | |
13836 // Fall through | |
13837 } | |
13838 } | |
13839 throw jsonDecoder.mismatch(jsonPath, "SearchResultKind", json); | |
13840 } | |
13841 | |
13842 @override | |
13843 String toString() => "SearchResultKind.$name"; | |
13844 | |
13845 String toJson() => name; | |
13846 } | |
13847 | |
13848 /** | |
13849 * ServerService | |
13850 * | |
13851 * enum { | |
13852 * STATUS | |
13853 * } | |
13854 */ | |
13855 class ServerService implements Enum { | |
13856 static const STATUS = const ServerService._("STATUS"); | |
13857 | |
13858 /** | |
13859 * A list containing all of the enum values that are defined. | |
13860 */ | |
13861 static const List<ServerService> VALUES = const <ServerService>[STATUS]; | |
13862 | |
13863 final String name; | |
13864 | |
13865 const ServerService._(this.name); | |
13866 | |
13867 factory ServerService(String name) { | |
13868 switch (name) { | |
13869 case "STATUS": | |
13870 return STATUS; | |
13871 } | |
13872 throw new Exception('Illegal enum value: $name'); | |
13873 } | |
13874 | |
13875 factory ServerService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Objec
t json) { | |
13876 if (json is String) { | |
13877 try { | |
13878 return new ServerService(json); | |
13879 } catch(_) { | |
13880 // Fall through | |
13881 } | |
13882 } | |
13883 throw jsonDecoder.mismatch(jsonPath, "ServerService", json); | |
13884 } | |
13885 | |
13886 @override | |
13887 String toString() => "ServerService.$name"; | |
13888 | |
13889 String toJson() => name; | |
13890 } | |
13891 | |
13892 /** | |
13893 * SourceChange | |
13894 * | |
13895 * { | |
13896 * "message": String | |
13897 * "edits": List<SourceFileEdit> | |
13898 * "linkedEditGroups": List<LinkedEditGroup> | |
13899 * "selection": optional Position | |
13900 * } | |
13901 */ | |
13902 class SourceChange implements HasToJson { | |
13903 String _message; | |
13904 | |
13905 List<SourceFileEdit> _edits; | |
13906 | |
13907 List<LinkedEditGroup> _linkedEditGroups; | |
13908 | |
13909 Position _selection; | |
13910 | |
13911 /** | |
13912 * A human-readable description of the change to be applied. | |
13913 */ | |
13914 String get message => _message; | |
13915 | |
13916 /** | |
13917 * A human-readable description of the change to be applied. | |
13918 */ | |
13919 void set message(String value) { | |
13920 assert(value != null); | |
13921 this._message = value; | |
13922 } | |
13923 | |
13924 /** | |
13925 * A list of the edits used to effect the change, grouped by file. | |
13926 */ | |
13927 List<SourceFileEdit> get edits => _edits; | |
13928 | |
13929 /** | |
13930 * A list of the edits used to effect the change, grouped by file. | |
13931 */ | |
13932 void set edits(List<SourceFileEdit> value) { | |
13933 assert(value != null); | |
13934 this._edits = value; | |
13935 } | |
13936 | |
13937 /** | |
13938 * A list of the linked editing groups used to customize the changes that | |
13939 * were made. | |
13940 */ | |
13941 List<LinkedEditGroup> get linkedEditGroups => _linkedEditGroups; | |
13942 | |
13943 /** | |
13944 * A list of the linked editing groups used to customize the changes that | |
13945 * were made. | |
13946 */ | |
13947 void set linkedEditGroups(List<LinkedEditGroup> value) { | |
13948 assert(value != null); | |
13949 this._linkedEditGroups = value; | |
13950 } | |
13951 | |
13952 /** | |
13953 * The position that should be selected after the edits have been applied. | |
13954 */ | |
13955 Position get selection => _selection; | |
13956 | |
13957 /** | |
13958 * The position that should be selected after the edits have been applied. | |
13959 */ | |
13960 void set selection(Position value) { | |
13961 this._selection = value; | |
13962 } | |
13963 | |
13964 SourceChange(String message, {List<SourceFileEdit> edits, List<LinkedEditGroup
> linkedEditGroups, Position selection}) { | |
13965 this.message = message; | |
13966 if (edits == null) { | |
13967 this.edits = <SourceFileEdit>[]; | |
13968 } else { | |
13969 this.edits = edits; | |
13970 } | |
13971 if (linkedEditGroups == null) { | |
13972 this.linkedEditGroups = <LinkedEditGroup>[]; | |
13973 } else { | |
13974 this.linkedEditGroups = linkedEditGroups; | |
13975 } | |
13976 this.selection = selection; | |
13977 } | |
13978 | |
13979 factory SourceChange.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object
json) { | |
13980 if (json == null) { | |
13981 json = {}; | |
13982 } | |
13983 if (json is Map) { | |
13984 String message; | |
13985 if (json.containsKey("message")) { | |
13986 message = jsonDecoder._decodeString(jsonPath + ".message", json["message
"]); | |
13987 } else { | |
13988 throw jsonDecoder.missingKey(jsonPath, "message"); | |
13989 } | |
13990 List<SourceFileEdit> edits; | |
13991 if (json.containsKey("edits")) { | |
13992 edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (Str
ing jsonPath, Object json) => new SourceFileEdit.fromJson(jsonDecoder, jsonPath,
json)); | |
13993 } else { | |
13994 throw jsonDecoder.missingKey(jsonPath, "edits"); | |
13995 } | |
13996 List<LinkedEditGroup> linkedEditGroups; | |
13997 if (json.containsKey("linkedEditGroups")) { | |
13998 linkedEditGroups = jsonDecoder._decodeList(jsonPath + ".linkedEditGroups
", json["linkedEditGroups"], (String jsonPath, Object json) => new LinkedEditGro
up.fromJson(jsonDecoder, jsonPath, json)); | |
13999 } else { | |
14000 throw jsonDecoder.missingKey(jsonPath, "linkedEditGroups"); | |
14001 } | |
14002 Position selection; | |
14003 if (json.containsKey("selection")) { | |
14004 selection = new Position.fromJson(jsonDecoder, jsonPath + ".selection",
json["selection"]); | |
14005 } | |
14006 return new SourceChange(message, edits: edits, linkedEditGroups: linkedEdi
tGroups, selection: selection); | |
14007 } else { | |
14008 throw jsonDecoder.mismatch(jsonPath, "SourceChange", json); | |
14009 } | |
14010 } | |
14011 | |
14012 Map<String, dynamic> toJson() { | |
14013 Map<String, dynamic> result = {}; | |
14014 result["message"] = message; | |
14015 result["edits"] = edits.map((SourceFileEdit value) => value.toJson()).toList
(); | |
14016 result["linkedEditGroups"] = linkedEditGroups.map((LinkedEditGroup value) =>
value.toJson()).toList(); | |
14017 if (selection != null) { | |
14018 result["selection"] = selection.toJson(); | |
14019 } | |
14020 return result; | |
14021 } | |
14022 | |
14023 /** | |
14024 * Adds [edit] to the [FileEdit] for the given [file]. | |
14025 */ | |
14026 void addEdit(String file, int fileStamp, SourceEdit edit) => | |
14027 _addEditToSourceChange(this, file, fileStamp, edit); | |
14028 | |
14029 /** | |
14030 * Adds the given [FileEdit]. | |
14031 */ | |
14032 void addFileEdit(SourceFileEdit edit) { | |
14033 edits.add(edit); | |
14034 } | |
14035 | |
14036 /** | |
14037 * Adds the given [LinkedEditGroup]. | |
14038 */ | |
14039 void addLinkedEditGroup(LinkedEditGroup linkedEditGroup) { | |
14040 linkedEditGroups.add(linkedEditGroup); | |
14041 } | |
14042 | |
14043 /** | |
14044 * Returns the [FileEdit] for the given [file], maybe `null`. | |
14045 */ | |
14046 SourceFileEdit getFileEdit(String file) => | |
14047 _getChangeFileEdit(this, file); | |
14048 | |
14049 @override | |
14050 String toString() => JSON.encode(toJson()); | |
14051 | |
14052 @override | |
14053 bool operator==(other) { | |
14054 if (other is SourceChange) { | |
14055 return message == other.message && | |
14056 _listEqual(edits, other.edits, (SourceFileEdit a, SourceFileEdit b) =>
a == b) && | |
14057 _listEqual(linkedEditGroups, other.linkedEditGroups, (LinkedEditGroup
a, LinkedEditGroup b) => a == b) && | |
14058 selection == other.selection; | |
14059 } | |
14060 return false; | |
14061 } | |
14062 | |
14063 @override | |
14064 int get hashCode { | |
14065 int hash = 0; | |
14066 hash = _JenkinsSmiHash.combine(hash, message.hashCode); | |
14067 hash = _JenkinsSmiHash.combine(hash, edits.hashCode); | |
14068 hash = _JenkinsSmiHash.combine(hash, linkedEditGroups.hashCode); | |
14069 hash = _JenkinsSmiHash.combine(hash, selection.hashCode); | |
14070 return _JenkinsSmiHash.finish(hash); | |
14071 } | |
14072 } | |
14073 | |
14074 /** | |
14075 * SourceEdit | |
14076 * | |
14077 * { | |
14078 * "offset": int | |
14079 * "length": int | |
14080 * "replacement": String | |
14081 * "id": optional String | |
14082 * } | |
14083 */ | |
14084 class SourceEdit implements HasToJson { | |
14085 /** | |
14086 * Get the result of applying a set of [edits] to the given [code]. Edits are | |
14087 * applied in the order they appear in [edits]. | |
14088 */ | |
14089 static String applySequence(String code, Iterable<SourceEdit> edits) => | |
14090 _applySequence(code, edits); | |
14091 | |
14092 int _offset; | |
14093 | |
14094 int _length; | |
14095 | |
14096 String _replacement; | |
14097 | |
14098 String _id; | |
14099 | |
14100 /** | |
14101 * The offset of the region to be modified. | |
14102 */ | |
14103 int get offset => _offset; | |
14104 | |
14105 /** | |
14106 * The offset of the region to be modified. | |
14107 */ | |
14108 void set offset(int value) { | |
14109 assert(value != null); | |
14110 this._offset = value; | |
14111 } | |
14112 | |
14113 /** | |
14114 * The length of the region to be modified. | |
14115 */ | |
14116 int get length => _length; | |
14117 | |
14118 /** | |
14119 * The length of the region to be modified. | |
14120 */ | |
14121 void set length(int value) { | |
14122 assert(value != null); | |
14123 this._length = value; | |
14124 } | |
14125 | |
14126 /** | |
14127 * The code that is to replace the specified region in the original code. | |
14128 */ | |
14129 String get replacement => _replacement; | |
14130 | |
14131 /** | |
14132 * The code that is to replace the specified region in the original code. | |
14133 */ | |
14134 void set replacement(String value) { | |
14135 assert(value != null); | |
14136 this._replacement = value; | |
14137 } | |
14138 | |
14139 /** | |
14140 * An identifier that uniquely identifies this source edit from other edits | |
14141 * in the same response. This field is omitted unless a containing structure | |
14142 * needs to be able to identify the edit for some reason. | |
14143 * | |
14144 * For example, some refactoring operations can produce edits that might not | |
14145 * be appropriate (referred to as potential edits). Such edits will have an | |
14146 * id so that they can be referenced. Edits in the same response that do not | |
14147 * need to be referenced will not have an id. | |
14148 */ | |
14149 String get id => _id; | |
14150 | |
14151 /** | |
14152 * An identifier that uniquely identifies this source edit from other edits | |
14153 * in the same response. This field is omitted unless a containing structure | |
14154 * needs to be able to identify the edit for some reason. | |
14155 * | |
14156 * For example, some refactoring operations can produce edits that might not | |
14157 * be appropriate (referred to as potential edits). Such edits will have an | |
14158 * id so that they can be referenced. Edits in the same response that do not | |
14159 * need to be referenced will not have an id. | |
14160 */ | |
14161 void set id(String value) { | |
14162 this._id = value; | |
14163 } | |
14164 | |
14165 SourceEdit(int offset, int length, String replacement, {String id}) { | |
14166 this.offset = offset; | |
14167 this.length = length; | |
14168 this.replacement = replacement; | |
14169 this.id = id; | |
14170 } | |
14171 | |
14172 factory SourceEdit.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object j
son) { | |
14173 if (json == null) { | |
14174 json = {}; | |
14175 } | |
14176 if (json is Map) { | |
14177 int offset; | |
14178 if (json.containsKey("offset")) { | |
14179 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
14180 } else { | |
14181 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
14182 } | |
14183 int length; | |
14184 if (json.containsKey("length")) { | |
14185 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
14186 } else { | |
14187 throw jsonDecoder.missingKey(jsonPath, "length"); | |
14188 } | |
14189 String replacement; | |
14190 if (json.containsKey("replacement")) { | |
14191 replacement = jsonDecoder._decodeString(jsonPath + ".replacement", json[
"replacement"]); | |
14192 } else { | |
14193 throw jsonDecoder.missingKey(jsonPath, "replacement"); | |
14194 } | |
14195 String id; | |
14196 if (json.containsKey("id")) { | |
14197 id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]); | |
14198 } | |
14199 return new SourceEdit(offset, length, replacement, id: id); | |
14200 } else { | |
14201 throw jsonDecoder.mismatch(jsonPath, "SourceEdit", json); | |
14202 } | |
14203 } | |
14204 | |
14205 /** | |
14206 * The end of the region to be modified. | |
14207 */ | |
14208 int get end => offset + length; | |
14209 | |
14210 Map<String, dynamic> toJson() { | |
14211 Map<String, dynamic> result = {}; | |
14212 result["offset"] = offset; | |
14213 result["length"] = length; | |
14214 result["replacement"] = replacement; | |
14215 if (id != null) { | |
14216 result["id"] = id; | |
14217 } | |
14218 return result; | |
14219 } | |
14220 | |
14221 /** | |
14222 * Get the result of applying the edit to the given [code]. | |
14223 */ | |
14224 String apply(String code) => _applyEdit(code, this); | |
14225 | |
14226 @override | |
14227 String toString() => JSON.encode(toJson()); | |
14228 | |
14229 @override | |
14230 bool operator==(other) { | |
14231 if (other is SourceEdit) { | |
14232 return offset == other.offset && | |
14233 length == other.length && | |
14234 replacement == other.replacement && | |
14235 id == other.id; | |
14236 } | |
14237 return false; | |
14238 } | |
14239 | |
14240 @override | |
14241 int get hashCode { | |
14242 int hash = 0; | |
14243 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
14244 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
14245 hash = _JenkinsSmiHash.combine(hash, replacement.hashCode); | |
14246 hash = _JenkinsSmiHash.combine(hash, id.hashCode); | |
14247 return _JenkinsSmiHash.finish(hash); | |
14248 } | |
14249 } | |
14250 | |
14251 /** | |
14252 * SourceFileEdit | |
14253 * | |
14254 * { | |
14255 * "file": FilePath | |
14256 * "fileStamp": long | |
14257 * "edits": List<SourceEdit> | |
14258 * } | |
14259 */ | |
14260 class SourceFileEdit implements HasToJson { | |
14261 String _file; | |
14262 | |
14263 int _fileStamp; | |
14264 | |
14265 List<SourceEdit> _edits; | |
14266 | |
14267 /** | |
14268 * The file containing the code to be modified. | |
14269 */ | |
14270 String get file => _file; | |
14271 | |
14272 /** | |
14273 * The file containing the code to be modified. | |
14274 */ | |
14275 void set file(String value) { | |
14276 assert(value != null); | |
14277 this._file = value; | |
14278 } | |
14279 | |
14280 /** | |
14281 * The modification stamp of the file at the moment when the change was | |
14282 * created, in milliseconds since the "Unix epoch". Will be -1 if the file | |
14283 * did not exist and should be created. The client may use this field to make | |
14284 * sure that the file was not changed since then, so it is safe to apply the | |
14285 * change. | |
14286 */ | |
14287 int get fileStamp => _fileStamp; | |
14288 | |
14289 /** | |
14290 * The modification stamp of the file at the moment when the change was | |
14291 * created, in milliseconds since the "Unix epoch". Will be -1 if the file | |
14292 * did not exist and should be created. The client may use this field to make | |
14293 * sure that the file was not changed since then, so it is safe to apply the | |
14294 * change. | |
14295 */ | |
14296 void set fileStamp(int value) { | |
14297 assert(value != null); | |
14298 this._fileStamp = value; | |
14299 } | |
14300 | |
14301 /** | |
14302 * A list of the edits used to effect the change. | |
14303 */ | |
14304 List<SourceEdit> get edits => _edits; | |
14305 | |
14306 /** | |
14307 * A list of the edits used to effect the change. | |
14308 */ | |
14309 void set edits(List<SourceEdit> value) { | |
14310 assert(value != null); | |
14311 this._edits = value; | |
14312 } | |
14313 | |
14314 SourceFileEdit(String file, int fileStamp, {List<SourceEdit> edits}) { | |
14315 this.file = file; | |
14316 this.fileStamp = fileStamp; | |
14317 if (edits == null) { | |
14318 this.edits = <SourceEdit>[]; | |
14319 } else { | |
14320 this.edits = edits; | |
14321 } | |
14322 } | |
14323 | |
14324 factory SourceFileEdit.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obje
ct json) { | |
14325 if (json == null) { | |
14326 json = {}; | |
14327 } | |
14328 if (json is Map) { | |
14329 String file; | |
14330 if (json.containsKey("file")) { | |
14331 file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]); | |
14332 } else { | |
14333 throw jsonDecoder.missingKey(jsonPath, "file"); | |
14334 } | |
14335 int fileStamp; | |
14336 if (json.containsKey("fileStamp")) { | |
14337 fileStamp = jsonDecoder._decodeInt(jsonPath + ".fileStamp", json["fileSt
amp"]); | |
14338 } else { | |
14339 throw jsonDecoder.missingKey(jsonPath, "fileStamp"); | |
14340 } | |
14341 List<SourceEdit> edits; | |
14342 if (json.containsKey("edits")) { | |
14343 edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (Str
ing jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, jso
n)); | |
14344 } else { | |
14345 throw jsonDecoder.missingKey(jsonPath, "edits"); | |
14346 } | |
14347 return new SourceFileEdit(file, fileStamp, edits: edits); | |
14348 } else { | |
14349 throw jsonDecoder.mismatch(jsonPath, "SourceFileEdit", json); | |
14350 } | |
14351 } | |
14352 | |
14353 Map<String, dynamic> toJson() { | |
14354 Map<String, dynamic> result = {}; | |
14355 result["file"] = file; | |
14356 result["fileStamp"] = fileStamp; | |
14357 result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList(); | |
14358 return result; | |
14359 } | |
14360 | |
14361 /** | |
14362 * Adds the given [Edit] to the list. | |
14363 */ | |
14364 void add(SourceEdit edit) => _addEditForSource(this, edit); | |
14365 | |
14366 /** | |
14367 * Adds the given [Edit]s. | |
14368 */ | |
14369 void addAll(Iterable<SourceEdit> edits) => | |
14370 _addAllEditsForSource(this, edits); | |
14371 | |
14372 @override | |
14373 String toString() => JSON.encode(toJson()); | |
14374 | |
14375 @override | |
14376 bool operator==(other) { | |
14377 if (other is SourceFileEdit) { | |
14378 return file == other.file && | |
14379 fileStamp == other.fileStamp && | |
14380 _listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b)
; | |
14381 } | |
14382 return false; | |
14383 } | |
14384 | |
14385 @override | |
14386 int get hashCode { | |
14387 int hash = 0; | |
14388 hash = _JenkinsSmiHash.combine(hash, file.hashCode); | |
14389 hash = _JenkinsSmiHash.combine(hash, fileStamp.hashCode); | |
14390 hash = _JenkinsSmiHash.combine(hash, edits.hashCode); | |
14391 return _JenkinsSmiHash.finish(hash); | |
14392 } | |
14393 } | |
14394 | |
14395 /** | |
14396 * TypeHierarchyItem | |
14397 * | |
14398 * { | |
14399 * "classElement": Element | |
14400 * "displayName": optional String | |
14401 * "memberElement": optional Element | |
14402 * "superclass": optional int | |
14403 * "interfaces": List<int> | |
14404 * "mixins": List<int> | |
14405 * "subclasses": List<int> | |
14406 * } | |
14407 */ | |
14408 class TypeHierarchyItem implements HasToJson { | |
14409 Element _classElement; | |
14410 | |
14411 String _displayName; | |
14412 | |
14413 Element _memberElement; | |
14414 | |
14415 int _superclass; | |
14416 | |
14417 List<int> _interfaces; | |
14418 | |
14419 List<int> _mixins; | |
14420 | |
14421 List<int> _subclasses; | |
14422 | |
14423 /** | |
14424 * The class element represented by this item. | |
14425 */ | |
14426 Element get classElement => _classElement; | |
14427 | |
14428 /** | |
14429 * The class element represented by this item. | |
14430 */ | |
14431 void set classElement(Element value) { | |
14432 assert(value != null); | |
14433 this._classElement = value; | |
14434 } | |
14435 | |
14436 /** | |
14437 * The name to be displayed for the class. This field will be omitted if the | |
14438 * display name is the same as the name of the element. The display name is | |
14439 * different if there is additional type information to be displayed, such as | |
14440 * type arguments. | |
14441 */ | |
14442 String get displayName => _displayName; | |
14443 | |
14444 /** | |
14445 * The name to be displayed for the class. This field will be omitted if the | |
14446 * display name is the same as the name of the element. The display name is | |
14447 * different if there is additional type information to be displayed, such as | |
14448 * type arguments. | |
14449 */ | |
14450 void set displayName(String value) { | |
14451 this._displayName = value; | |
14452 } | |
14453 | |
14454 /** | |
14455 * The member in the class corresponding to the member on which the hierarchy | |
14456 * was requested. This field will be omitted if the hierarchy was not | |
14457 * requested for a member or if the class does not have a corresponding | |
14458 * member. | |
14459 */ | |
14460 Element get memberElement => _memberElement; | |
14461 | |
14462 /** | |
14463 * The member in the class corresponding to the member on which the hierarchy | |
14464 * was requested. This field will be omitted if the hierarchy was not | |
14465 * requested for a member or if the class does not have a corresponding | |
14466 * member. | |
14467 */ | |
14468 void set memberElement(Element value) { | |
14469 this._memberElement = value; | |
14470 } | |
14471 | |
14472 /** | |
14473 * The index of the item representing the superclass of this class. This | |
14474 * field will be omitted if this item represents the class Object. | |
14475 */ | |
14476 int get superclass => _superclass; | |
14477 | |
14478 /** | |
14479 * The index of the item representing the superclass of this class. This | |
14480 * field will be omitted if this item represents the class Object. | |
14481 */ | |
14482 void set superclass(int value) { | |
14483 this._superclass = value; | |
14484 } | |
14485 | |
14486 /** | |
14487 * The indexes of the items representing the interfaces implemented by this | |
14488 * class. The list will be empty if there are no implemented interfaces. | |
14489 */ | |
14490 List<int> get interfaces => _interfaces; | |
14491 | |
14492 /** | |
14493 * The indexes of the items representing the interfaces implemented by this | |
14494 * class. The list will be empty if there are no implemented interfaces. | |
14495 */ | |
14496 void set interfaces(List<int> value) { | |
14497 assert(value != null); | |
14498 this._interfaces = value; | |
14499 } | |
14500 | |
14501 /** | |
14502 * The indexes of the items representing the mixins referenced by this class. | |
14503 * The list will be empty if there are no classes mixed in to this class. | |
14504 */ | |
14505 List<int> get mixins => _mixins; | |
14506 | |
14507 /** | |
14508 * The indexes of the items representing the mixins referenced by this class. | |
14509 * The list will be empty if there are no classes mixed in to this class. | |
14510 */ | |
14511 void set mixins(List<int> value) { | |
14512 assert(value != null); | |
14513 this._mixins = value; | |
14514 } | |
14515 | |
14516 /** | |
14517 * The indexes of the items representing the subtypes of this class. The list | |
14518 * will be empty if there are no subtypes or if this item represents a | |
14519 * supertype of the pivot type. | |
14520 */ | |
14521 List<int> get subclasses => _subclasses; | |
14522 | |
14523 /** | |
14524 * The indexes of the items representing the subtypes of this class. The list | |
14525 * will be empty if there are no subtypes or if this item represents a | |
14526 * supertype of the pivot type. | |
14527 */ | |
14528 void set subclasses(List<int> value) { | |
14529 assert(value != null); | |
14530 this._subclasses = value; | |
14531 } | |
14532 | |
14533 TypeHierarchyItem(Element classElement, {String displayName, Element memberEle
ment, int superclass, List<int> interfaces, List<int> mixins, List<int> subclass
es}) { | |
14534 this.classElement = classElement; | |
14535 this.displayName = displayName; | |
14536 this.memberElement = memberElement; | |
14537 this.superclass = superclass; | |
14538 if (interfaces == null) { | |
14539 this.interfaces = <int>[]; | |
14540 } else { | |
14541 this.interfaces = interfaces; | |
14542 } | |
14543 if (mixins == null) { | |
14544 this.mixins = <int>[]; | |
14545 } else { | |
14546 this.mixins = mixins; | |
14547 } | |
14548 if (subclasses == null) { | |
14549 this.subclasses = <int>[]; | |
14550 } else { | |
14551 this.subclasses = subclasses; | |
14552 } | |
14553 } | |
14554 | |
14555 factory TypeHierarchyItem.fromJson(JsonDecoder jsonDecoder, String jsonPath, O
bject json) { | |
14556 if (json == null) { | |
14557 json = {}; | |
14558 } | |
14559 if (json is Map) { | |
14560 Element classElement; | |
14561 if (json.containsKey("classElement")) { | |
14562 classElement = new Element.fromJson(jsonDecoder, jsonPath + ".classEleme
nt", json["classElement"]); | |
14563 } else { | |
14564 throw jsonDecoder.missingKey(jsonPath, "classElement"); | |
14565 } | |
14566 String displayName; | |
14567 if (json.containsKey("displayName")) { | |
14568 displayName = jsonDecoder._decodeString(jsonPath + ".displayName", json[
"displayName"]); | |
14569 } | |
14570 Element memberElement; | |
14571 if (json.containsKey("memberElement")) { | |
14572 memberElement = new Element.fromJson(jsonDecoder, jsonPath + ".memberEle
ment", json["memberElement"]); | |
14573 } | |
14574 int superclass; | |
14575 if (json.containsKey("superclass")) { | |
14576 superclass = jsonDecoder._decodeInt(jsonPath + ".superclass", json["supe
rclass"]); | |
14577 } | |
14578 List<int> interfaces; | |
14579 if (json.containsKey("interfaces")) { | |
14580 interfaces = jsonDecoder._decodeList(jsonPath + ".interfaces", json["int
erfaces"], jsonDecoder._decodeInt); | |
14581 } else { | |
14582 throw jsonDecoder.missingKey(jsonPath, "interfaces"); | |
14583 } | |
14584 List<int> mixins; | |
14585 if (json.containsKey("mixins")) { | |
14586 mixins = jsonDecoder._decodeList(jsonPath + ".mixins", json["mixins"], j
sonDecoder._decodeInt); | |
14587 } else { | |
14588 throw jsonDecoder.missingKey(jsonPath, "mixins"); | |
14589 } | |
14590 List<int> subclasses; | |
14591 if (json.containsKey("subclasses")) { | |
14592 subclasses = jsonDecoder._decodeList(jsonPath + ".subclasses", json["sub
classes"], jsonDecoder._decodeInt); | |
14593 } else { | |
14594 throw jsonDecoder.missingKey(jsonPath, "subclasses"); | |
14595 } | |
14596 return new TypeHierarchyItem(classElement, displayName: displayName, membe
rElement: memberElement, superclass: superclass, interfaces: interfaces, mixins:
mixins, subclasses: subclasses); | |
14597 } else { | |
14598 throw jsonDecoder.mismatch(jsonPath, "TypeHierarchyItem", json); | |
14599 } | |
14600 } | |
14601 | |
14602 Map<String, dynamic> toJson() { | |
14603 Map<String, dynamic> result = {}; | |
14604 result["classElement"] = classElement.toJson(); | |
14605 if (displayName != null) { | |
14606 result["displayName"] = displayName; | |
14607 } | |
14608 if (memberElement != null) { | |
14609 result["memberElement"] = memberElement.toJson(); | |
14610 } | |
14611 if (superclass != null) { | |
14612 result["superclass"] = superclass; | |
14613 } | |
14614 result["interfaces"] = interfaces; | |
14615 result["mixins"] = mixins; | |
14616 result["subclasses"] = subclasses; | |
14617 return result; | |
14618 } | |
14619 | |
14620 @override | |
14621 String toString() => JSON.encode(toJson()); | |
14622 | |
14623 @override | |
14624 bool operator==(other) { | |
14625 if (other is TypeHierarchyItem) { | |
14626 return classElement == other.classElement && | |
14627 displayName == other.displayName && | |
14628 memberElement == other.memberElement && | |
14629 superclass == other.superclass && | |
14630 _listEqual(interfaces, other.interfaces, (int a, int b) => a == b) && | |
14631 _listEqual(mixins, other.mixins, (int a, int b) => a == b) && | |
14632 _listEqual(subclasses, other.subclasses, (int a, int b) => a == b); | |
14633 } | |
14634 return false; | |
14635 } | |
14636 | |
14637 @override | |
14638 int get hashCode { | |
14639 int hash = 0; | |
14640 hash = _JenkinsSmiHash.combine(hash, classElement.hashCode); | |
14641 hash = _JenkinsSmiHash.combine(hash, displayName.hashCode); | |
14642 hash = _JenkinsSmiHash.combine(hash, memberElement.hashCode); | |
14643 hash = _JenkinsSmiHash.combine(hash, superclass.hashCode); | |
14644 hash = _JenkinsSmiHash.combine(hash, interfaces.hashCode); | |
14645 hash = _JenkinsSmiHash.combine(hash, mixins.hashCode); | |
14646 hash = _JenkinsSmiHash.combine(hash, subclasses.hashCode); | |
14647 return _JenkinsSmiHash.finish(hash); | |
14648 } | |
14649 } | |
14650 /** | |
14651 * convertGetterToMethod feedback | |
14652 */ | |
14653 class ConvertGetterToMethodFeedback { | |
14654 @override | |
14655 bool operator==(other) { | |
14656 if (other is ConvertGetterToMethodFeedback) { | |
14657 return true; | |
14658 } | |
14659 return false; | |
14660 } | |
14661 | |
14662 @override | |
14663 int get hashCode { | |
14664 return 616032599; | |
14665 } | |
14666 } | |
14667 /** | |
14668 * convertGetterToMethod options | |
14669 */ | |
14670 class ConvertGetterToMethodOptions { | |
14671 @override | |
14672 bool operator==(other) { | |
14673 if (other is ConvertGetterToMethodOptions) { | |
14674 return true; | |
14675 } | |
14676 return false; | |
14677 } | |
14678 | |
14679 @override | |
14680 int get hashCode { | |
14681 return 488848400; | |
14682 } | |
14683 } | |
14684 /** | |
14685 * convertMethodToGetter feedback | |
14686 */ | |
14687 class ConvertMethodToGetterFeedback { | |
14688 @override | |
14689 bool operator==(other) { | |
14690 if (other is ConvertMethodToGetterFeedback) { | |
14691 return true; | |
14692 } | |
14693 return false; | |
14694 } | |
14695 | |
14696 @override | |
14697 int get hashCode { | |
14698 return 165291526; | |
14699 } | |
14700 } | |
14701 /** | |
14702 * convertMethodToGetter options | |
14703 */ | |
14704 class ConvertMethodToGetterOptions { | |
14705 @override | |
14706 bool operator==(other) { | |
14707 if (other is ConvertMethodToGetterOptions) { | |
14708 return true; | |
14709 } | |
14710 return false; | |
14711 } | |
14712 | |
14713 @override | |
14714 int get hashCode { | |
14715 return 27952290; | |
14716 } | |
14717 } | |
14718 | |
14719 /** | |
14720 * extractLocalVariable feedback | |
14721 * | |
14722 * { | |
14723 * "coveringExpressionOffsets": List<int> | |
14724 * "coveringExpressionLengths": List<int> | |
14725 * "names": List<String> | |
14726 * "offsets": List<int> | |
14727 * "lengths": List<int> | |
14728 * } | |
14729 */ | |
14730 class ExtractLocalVariableFeedback extends RefactoringFeedback implements HasToJ
son { | |
14731 List<int> _coveringExpressionOffsets; | |
14732 | |
14733 List<int> _coveringExpressionLengths; | |
14734 | |
14735 List<String> _names; | |
14736 | |
14737 List<int> _offsets; | |
14738 | |
14739 List<int> _lengths; | |
14740 | |
14741 /** | |
14742 * The offsets of the expressions that cover the specified selection, from | |
14743 * the down most to the up most. | |
14744 */ | |
14745 List<int> get coveringExpressionOffsets => _coveringExpressionOffsets; | |
14746 | |
14747 /** | |
14748 * The offsets of the expressions that cover the specified selection, from | |
14749 * the down most to the up most. | |
14750 */ | |
14751 void set coveringExpressionOffsets(List<int> value) { | |
14752 assert(value != null); | |
14753 this._coveringExpressionOffsets = value; | |
14754 } | |
14755 | |
14756 /** | |
14757 * The lengths of the expressions that cover the specified selection, from | |
14758 * the down most to the up most. | |
14759 */ | |
14760 List<int> get coveringExpressionLengths => _coveringExpressionLengths; | |
14761 | |
14762 /** | |
14763 * The lengths of the expressions that cover the specified selection, from | |
14764 * the down most to the up most. | |
14765 */ | |
14766 void set coveringExpressionLengths(List<int> value) { | |
14767 assert(value != null); | |
14768 this._coveringExpressionLengths = value; | |
14769 } | |
14770 | |
14771 /** | |
14772 * The proposed names for the local variable. | |
14773 */ | |
14774 List<String> get names => _names; | |
14775 | |
14776 /** | |
14777 * The proposed names for the local variable. | |
14778 */ | |
14779 void set names(List<String> value) { | |
14780 assert(value != null); | |
14781 this._names = value; | |
14782 } | |
14783 | |
14784 /** | |
14785 * The offsets of the expressions that would be replaced by a reference to | |
14786 * the variable. | |
14787 */ | |
14788 List<int> get offsets => _offsets; | |
14789 | |
14790 /** | |
14791 * The offsets of the expressions that would be replaced by a reference to | |
14792 * the variable. | |
14793 */ | |
14794 void set offsets(List<int> value) { | |
14795 assert(value != null); | |
14796 this._offsets = value; | |
14797 } | |
14798 | |
14799 /** | |
14800 * The lengths of the expressions that would be replaced by a reference to | |
14801 * the variable. The lengths correspond to the offsets. In other words, for a | |
14802 * given expression, if the offset of that expression is offsets[i], then the | |
14803 * length of that expression is lengths[i]. | |
14804 */ | |
14805 List<int> get lengths => _lengths; | |
14806 | |
14807 /** | |
14808 * The lengths of the expressions that would be replaced by a reference to | |
14809 * the variable. The lengths correspond to the offsets. In other words, for a | |
14810 * given expression, if the offset of that expression is offsets[i], then the | |
14811 * length of that expression is lengths[i]. | |
14812 */ | |
14813 void set lengths(List<int> value) { | |
14814 assert(value != null); | |
14815 this._lengths = value; | |
14816 } | |
14817 | |
14818 ExtractLocalVariableFeedback(List<int> coveringExpressionOffsets, List<int> co
veringExpressionLengths, List<String> names, List<int> offsets, List<int> length
s) { | |
14819 this.coveringExpressionOffsets = coveringExpressionOffsets; | |
14820 this.coveringExpressionLengths = coveringExpressionLengths; | |
14821 this.names = names; | |
14822 this.offsets = offsets; | |
14823 this.lengths = lengths; | |
14824 } | |
14825 | |
14826 factory ExtractLocalVariableFeedback.fromJson(JsonDecoder jsonDecoder, String
jsonPath, Object json) { | |
14827 if (json == null) { | |
14828 json = {}; | |
14829 } | |
14830 if (json is Map) { | |
14831 List<int> coveringExpressionOffsets; | |
14832 if (json.containsKey("coveringExpressionOffsets")) { | |
14833 coveringExpressionOffsets = jsonDecoder._decodeList(jsonPath + ".coverin
gExpressionOffsets", json["coveringExpressionOffsets"], jsonDecoder._decodeInt); | |
14834 } else { | |
14835 throw jsonDecoder.missingKey(jsonPath, "coveringExpressionOffsets"); | |
14836 } | |
14837 List<int> coveringExpressionLengths; | |
14838 if (json.containsKey("coveringExpressionLengths")) { | |
14839 coveringExpressionLengths = jsonDecoder._decodeList(jsonPath + ".coverin
gExpressionLengths", json["coveringExpressionLengths"], jsonDecoder._decodeInt); | |
14840 } else { | |
14841 throw jsonDecoder.missingKey(jsonPath, "coveringExpressionLengths"); | |
14842 } | |
14843 List<String> names; | |
14844 if (json.containsKey("names")) { | |
14845 names = jsonDecoder._decodeList(jsonPath + ".names", json["names"], json
Decoder._decodeString); | |
14846 } else { | |
14847 throw jsonDecoder.missingKey(jsonPath, "names"); | |
14848 } | |
14849 List<int> offsets; | |
14850 if (json.containsKey("offsets")) { | |
14851 offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"]
, jsonDecoder._decodeInt); | |
14852 } else { | |
14853 throw jsonDecoder.missingKey(jsonPath, "offsets"); | |
14854 } | |
14855 List<int> lengths; | |
14856 if (json.containsKey("lengths")) { | |
14857 lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"]
, jsonDecoder._decodeInt); | |
14858 } else { | |
14859 throw jsonDecoder.missingKey(jsonPath, "lengths"); | |
14860 } | |
14861 return new ExtractLocalVariableFeedback(coveringExpressionOffsets, coverin
gExpressionLengths, names, offsets, lengths); | |
14862 } else { | |
14863 throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback", json
); | |
14864 } | |
14865 } | |
14866 | |
14867 Map<String, dynamic> toJson() { | |
14868 Map<String, dynamic> result = {}; | |
14869 result["coveringExpressionOffsets"] = coveringExpressionOffsets; | |
14870 result["coveringExpressionLengths"] = coveringExpressionLengths; | |
14871 result["names"] = names; | |
14872 result["offsets"] = offsets; | |
14873 result["lengths"] = lengths; | |
14874 return result; | |
14875 } | |
14876 | |
14877 @override | |
14878 String toString() => JSON.encode(toJson()); | |
14879 | |
14880 @override | |
14881 bool operator==(other) { | |
14882 if (other is ExtractLocalVariableFeedback) { | |
14883 return _listEqual(coveringExpressionOffsets, other.coveringExpressionOffse
ts, (int a, int b) => a == b) && | |
14884 _listEqual(coveringExpressionLengths, other.coveringExpressionLengths,
(int a, int b) => a == b) && | |
14885 _listEqual(names, other.names, (String a, String b) => a == b) && | |
14886 _listEqual(offsets, other.offsets, (int a, int b) => a == b) && | |
14887 _listEqual(lengths, other.lengths, (int a, int b) => a == b); | |
14888 } | |
14889 return false; | |
14890 } | |
14891 | |
14892 @override | |
14893 int get hashCode { | |
14894 int hash = 0; | |
14895 hash = _JenkinsSmiHash.combine(hash, coveringExpressionOffsets.hashCode); | |
14896 hash = _JenkinsSmiHash.combine(hash, coveringExpressionLengths.hashCode); | |
14897 hash = _JenkinsSmiHash.combine(hash, names.hashCode); | |
14898 hash = _JenkinsSmiHash.combine(hash, offsets.hashCode); | |
14899 hash = _JenkinsSmiHash.combine(hash, lengths.hashCode); | |
14900 return _JenkinsSmiHash.finish(hash); | |
14901 } | |
14902 } | |
14903 | |
14904 /** | |
14905 * extractLocalVariable options | |
14906 * | |
14907 * { | |
14908 * "name": String | |
14909 * "extractAll": bool | |
14910 * } | |
14911 */ | |
14912 class ExtractLocalVariableOptions extends RefactoringOptions implements HasToJso
n { | |
14913 String _name; | |
14914 | |
14915 bool _extractAll; | |
14916 | |
14917 /** | |
14918 * The name that the local variable should be given. | |
14919 */ | |
14920 String get name => _name; | |
14921 | |
14922 /** | |
14923 * The name that the local variable should be given. | |
14924 */ | |
14925 void set name(String value) { | |
14926 assert(value != null); | |
14927 this._name = value; | |
14928 } | |
14929 | |
14930 /** | |
14931 * True if all occurrences of the expression within the scope in which the | |
14932 * variable will be defined should be replaced by a reference to the local | |
14933 * variable. The expression used to initiate the refactoring will always be | |
14934 * replaced. | |
14935 */ | |
14936 bool get extractAll => _extractAll; | |
14937 | |
14938 /** | |
14939 * True if all occurrences of the expression within the scope in which the | |
14940 * variable will be defined should be replaced by a reference to the local | |
14941 * variable. The expression used to initiate the refactoring will always be | |
14942 * replaced. | |
14943 */ | |
14944 void set extractAll(bool value) { | |
14945 assert(value != null); | |
14946 this._extractAll = value; | |
14947 } | |
14948 | |
14949 ExtractLocalVariableOptions(String name, bool extractAll) { | |
14950 this.name = name; | |
14951 this.extractAll = extractAll; | |
14952 } | |
14953 | |
14954 factory ExtractLocalVariableOptions.fromJson(JsonDecoder jsonDecoder, String j
sonPath, Object json) { | |
14955 if (json == null) { | |
14956 json = {}; | |
14957 } | |
14958 if (json is Map) { | |
14959 String name; | |
14960 if (json.containsKey("name")) { | |
14961 name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]); | |
14962 } else { | |
14963 throw jsonDecoder.missingKey(jsonPath, "name"); | |
14964 } | |
14965 bool extractAll; | |
14966 if (json.containsKey("extractAll")) { | |
14967 extractAll = jsonDecoder._decodeBool(jsonPath + ".extractAll", json["ext
ractAll"]); | |
14968 } else { | |
14969 throw jsonDecoder.missingKey(jsonPath, "extractAll"); | |
14970 } | |
14971 return new ExtractLocalVariableOptions(name, extractAll); | |
14972 } else { | |
14973 throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable options", json)
; | |
14974 } | |
14975 } | |
14976 | |
14977 factory ExtractLocalVariableOptions.fromRefactoringParams(EditGetRefactoringPa
rams refactoringParams, Request request) { | |
14978 return new ExtractLocalVariableOptions.fromJson( | |
14979 new RequestDecoder(request), "options", refactoringParams.options); | |
14980 } | |
14981 | |
14982 Map<String, dynamic> toJson() { | |
14983 Map<String, dynamic> result = {}; | |
14984 result["name"] = name; | |
14985 result["extractAll"] = extractAll; | |
14986 return result; | |
14987 } | |
14988 | |
14989 @override | |
14990 String toString() => JSON.encode(toJson()); | |
14991 | |
14992 @override | |
14993 bool operator==(other) { | |
14994 if (other is ExtractLocalVariableOptions) { | |
14995 return name == other.name && | |
14996 extractAll == other.extractAll; | |
14997 } | |
14998 return false; | |
14999 } | |
15000 | |
15001 @override | |
15002 int get hashCode { | |
15003 int hash = 0; | |
15004 hash = _JenkinsSmiHash.combine(hash, name.hashCode); | |
15005 hash = _JenkinsSmiHash.combine(hash, extractAll.hashCode); | |
15006 return _JenkinsSmiHash.finish(hash); | |
15007 } | |
15008 } | |
15009 | |
15010 /** | |
15011 * extractMethod feedback | |
15012 * | |
15013 * { | |
15014 * "offset": int | |
15015 * "length": int | |
15016 * "returnType": String | |
15017 * "names": List<String> | |
15018 * "canCreateGetter": bool | |
15019 * "parameters": List<RefactoringMethodParameter> | |
15020 * "offsets": List<int> | |
15021 * "lengths": List<int> | |
15022 * } | |
15023 */ | |
15024 class ExtractMethodFeedback extends RefactoringFeedback implements HasToJson { | |
15025 int _offset; | |
15026 | |
15027 int _length; | |
15028 | |
15029 String _returnType; | |
15030 | |
15031 List<String> _names; | |
15032 | |
15033 bool _canCreateGetter; | |
15034 | |
15035 List<RefactoringMethodParameter> _parameters; | |
15036 | |
15037 List<int> _offsets; | |
15038 | |
15039 List<int> _lengths; | |
15040 | |
15041 /** | |
15042 * The offset to the beginning of the expression or statements that will be | |
15043 * extracted. | |
15044 */ | |
15045 int get offset => _offset; | |
15046 | |
15047 /** | |
15048 * The offset to the beginning of the expression or statements that will be | |
15049 * extracted. | |
15050 */ | |
15051 void set offset(int value) { | |
15052 assert(value != null); | |
15053 this._offset = value; | |
15054 } | |
15055 | |
15056 /** | |
15057 * The length of the expression or statements that will be extracted. | |
15058 */ | |
15059 int get length => _length; | |
15060 | |
15061 /** | |
15062 * The length of the expression or statements that will be extracted. | |
15063 */ | |
15064 void set length(int value) { | |
15065 assert(value != null); | |
15066 this._length = value; | |
15067 } | |
15068 | |
15069 /** | |
15070 * The proposed return type for the method. If the returned element does not | |
15071 * have a declared return type, this field will contain an empty string. | |
15072 */ | |
15073 String get returnType => _returnType; | |
15074 | |
15075 /** | |
15076 * The proposed return type for the method. If the returned element does not | |
15077 * have a declared return type, this field will contain an empty string. | |
15078 */ | |
15079 void set returnType(String value) { | |
15080 assert(value != null); | |
15081 this._returnType = value; | |
15082 } | |
15083 | |
15084 /** | |
15085 * The proposed names for the method. | |
15086 */ | |
15087 List<String> get names => _names; | |
15088 | |
15089 /** | |
15090 * The proposed names for the method. | |
15091 */ | |
15092 void set names(List<String> value) { | |
15093 assert(value != null); | |
15094 this._names = value; | |
15095 } | |
15096 | |
15097 /** | |
15098 * True if a getter could be created rather than a method. | |
15099 */ | |
15100 bool get canCreateGetter => _canCreateGetter; | |
15101 | |
15102 /** | |
15103 * True if a getter could be created rather than a method. | |
15104 */ | |
15105 void set canCreateGetter(bool value) { | |
15106 assert(value != null); | |
15107 this._canCreateGetter = value; | |
15108 } | |
15109 | |
15110 /** | |
15111 * The proposed parameters for the method. | |
15112 */ | |
15113 List<RefactoringMethodParameter> get parameters => _parameters; | |
15114 | |
15115 /** | |
15116 * The proposed parameters for the method. | |
15117 */ | |
15118 void set parameters(List<RefactoringMethodParameter> value) { | |
15119 assert(value != null); | |
15120 this._parameters = value; | |
15121 } | |
15122 | |
15123 /** | |
15124 * The offsets of the expressions or statements that would be replaced by an | |
15125 * invocation of the method. | |
15126 */ | |
15127 List<int> get offsets => _offsets; | |
15128 | |
15129 /** | |
15130 * The offsets of the expressions or statements that would be replaced by an | |
15131 * invocation of the method. | |
15132 */ | |
15133 void set offsets(List<int> value) { | |
15134 assert(value != null); | |
15135 this._offsets = value; | |
15136 } | |
15137 | |
15138 /** | |
15139 * The lengths of the expressions or statements that would be replaced by an | |
15140 * invocation of the method. The lengths correspond to the offsets. In other | |
15141 * words, for a given expression (or block of statements), if the offset of | |
15142 * that expression is offsets[i], then the length of that expression is | |
15143 * lengths[i]. | |
15144 */ | |
15145 List<int> get lengths => _lengths; | |
15146 | |
15147 /** | |
15148 * The lengths of the expressions or statements that would be replaced by an | |
15149 * invocation of the method. The lengths correspond to the offsets. In other | |
15150 * words, for a given expression (or block of statements), if the offset of | |
15151 * that expression is offsets[i], then the length of that expression is | |
15152 * lengths[i]. | |
15153 */ | |
15154 void set lengths(List<int> value) { | |
15155 assert(value != null); | |
15156 this._lengths = value; | |
15157 } | |
15158 | |
15159 ExtractMethodFeedback(int offset, int length, String returnType, List<String>
names, bool canCreateGetter, List<RefactoringMethodParameter> parameters, List<i
nt> offsets, List<int> lengths) { | |
15160 this.offset = offset; | |
15161 this.length = length; | |
15162 this.returnType = returnType; | |
15163 this.names = names; | |
15164 this.canCreateGetter = canCreateGetter; | |
15165 this.parameters = parameters; | |
15166 this.offsets = offsets; | |
15167 this.lengths = lengths; | |
15168 } | |
15169 | |
15170 factory ExtractMethodFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPat
h, Object json) { | |
15171 if (json == null) { | |
15172 json = {}; | |
15173 } | |
15174 if (json is Map) { | |
15175 int offset; | |
15176 if (json.containsKey("offset")) { | |
15177 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
15178 } else { | |
15179 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
15180 } | |
15181 int length; | |
15182 if (json.containsKey("length")) { | |
15183 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
15184 } else { | |
15185 throw jsonDecoder.missingKey(jsonPath, "length"); | |
15186 } | |
15187 String returnType; | |
15188 if (json.containsKey("returnType")) { | |
15189 returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["r
eturnType"]); | |
15190 } else { | |
15191 throw jsonDecoder.missingKey(jsonPath, "returnType"); | |
15192 } | |
15193 List<String> names; | |
15194 if (json.containsKey("names")) { | |
15195 names = jsonDecoder._decodeList(jsonPath + ".names", json["names"], json
Decoder._decodeString); | |
15196 } else { | |
15197 throw jsonDecoder.missingKey(jsonPath, "names"); | |
15198 } | |
15199 bool canCreateGetter; | |
15200 if (json.containsKey("canCreateGetter")) { | |
15201 canCreateGetter = jsonDecoder._decodeBool(jsonPath + ".canCreateGetter",
json["canCreateGetter"]); | |
15202 } else { | |
15203 throw jsonDecoder.missingKey(jsonPath, "canCreateGetter"); | |
15204 } | |
15205 List<RefactoringMethodParameter> parameters; | |
15206 if (json.containsKey("parameters")) { | |
15207 parameters = jsonDecoder._decodeList(jsonPath + ".parameters", json["par
ameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.from
Json(jsonDecoder, jsonPath, json)); | |
15208 } else { | |
15209 throw jsonDecoder.missingKey(jsonPath, "parameters"); | |
15210 } | |
15211 List<int> offsets; | |
15212 if (json.containsKey("offsets")) { | |
15213 offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"]
, jsonDecoder._decodeInt); | |
15214 } else { | |
15215 throw jsonDecoder.missingKey(jsonPath, "offsets"); | |
15216 } | |
15217 List<int> lengths; | |
15218 if (json.containsKey("lengths")) { | |
15219 lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"]
, jsonDecoder._decodeInt); | |
15220 } else { | |
15221 throw jsonDecoder.missingKey(jsonPath, "lengths"); | |
15222 } | |
15223 return new ExtractMethodFeedback(offset, length, returnType, names, canCre
ateGetter, parameters, offsets, lengths); | |
15224 } else { | |
15225 throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback", json); | |
15226 } | |
15227 } | |
15228 | |
15229 Map<String, dynamic> toJson() { | |
15230 Map<String, dynamic> result = {}; | |
15231 result["offset"] = offset; | |
15232 result["length"] = length; | |
15233 result["returnType"] = returnType; | |
15234 result["names"] = names; | |
15235 result["canCreateGetter"] = canCreateGetter; | |
15236 result["parameters"] = parameters.map((RefactoringMethodParameter value) =>
value.toJson()).toList(); | |
15237 result["offsets"] = offsets; | |
15238 result["lengths"] = lengths; | |
15239 return result; | |
15240 } | |
15241 | |
15242 @override | |
15243 String toString() => JSON.encode(toJson()); | |
15244 | |
15245 @override | |
15246 bool operator==(other) { | |
15247 if (other is ExtractMethodFeedback) { | |
15248 return offset == other.offset && | |
15249 length == other.length && | |
15250 returnType == other.returnType && | |
15251 _listEqual(names, other.names, (String a, String b) => a == b) && | |
15252 canCreateGetter == other.canCreateGetter && | |
15253 _listEqual(parameters, other.parameters, (RefactoringMethodParameter a
, RefactoringMethodParameter b) => a == b) && | |
15254 _listEqual(offsets, other.offsets, (int a, int b) => a == b) && | |
15255 _listEqual(lengths, other.lengths, (int a, int b) => a == b); | |
15256 } | |
15257 return false; | |
15258 } | |
15259 | |
15260 @override | |
15261 int get hashCode { | |
15262 int hash = 0; | |
15263 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
15264 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
15265 hash = _JenkinsSmiHash.combine(hash, returnType.hashCode); | |
15266 hash = _JenkinsSmiHash.combine(hash, names.hashCode); | |
15267 hash = _JenkinsSmiHash.combine(hash, canCreateGetter.hashCode); | |
15268 hash = _JenkinsSmiHash.combine(hash, parameters.hashCode); | |
15269 hash = _JenkinsSmiHash.combine(hash, offsets.hashCode); | |
15270 hash = _JenkinsSmiHash.combine(hash, lengths.hashCode); | |
15271 return _JenkinsSmiHash.finish(hash); | |
15272 } | |
15273 } | |
15274 | |
15275 /** | |
15276 * extractMethod options | |
15277 * | |
15278 * { | |
15279 * "returnType": String | |
15280 * "createGetter": bool | |
15281 * "name": String | |
15282 * "parameters": List<RefactoringMethodParameter> | |
15283 * "extractAll": bool | |
15284 * } | |
15285 */ | |
15286 class ExtractMethodOptions extends RefactoringOptions implements HasToJson { | |
15287 String _returnType; | |
15288 | |
15289 bool _createGetter; | |
15290 | |
15291 String _name; | |
15292 | |
15293 List<RefactoringMethodParameter> _parameters; | |
15294 | |
15295 bool _extractAll; | |
15296 | |
15297 /** | |
15298 * The return type that should be defined for the method. | |
15299 */ | |
15300 String get returnType => _returnType; | |
15301 | |
15302 /** | |
15303 * The return type that should be defined for the method. | |
15304 */ | |
15305 void set returnType(String value) { | |
15306 assert(value != null); | |
15307 this._returnType = value; | |
15308 } | |
15309 | |
15310 /** | |
15311 * True if a getter should be created rather than a method. It is an error if | |
15312 * this field is true and the list of parameters is non-empty. | |
15313 */ | |
15314 bool get createGetter => _createGetter; | |
15315 | |
15316 /** | |
15317 * True if a getter should be created rather than a method. It is an error if | |
15318 * this field is true and the list of parameters is non-empty. | |
15319 */ | |
15320 void set createGetter(bool value) { | |
15321 assert(value != null); | |
15322 this._createGetter = value; | |
15323 } | |
15324 | |
15325 /** | |
15326 * The name that the method should be given. | |
15327 */ | |
15328 String get name => _name; | |
15329 | |
15330 /** | |
15331 * The name that the method should be given. | |
15332 */ | |
15333 void set name(String value) { | |
15334 assert(value != null); | |
15335 this._name = value; | |
15336 } | |
15337 | |
15338 /** | |
15339 * The parameters that should be defined for the method. | |
15340 * | |
15341 * It is an error if a REQUIRED or NAMED parameter follows a POSITIONAL | |
15342 * parameter. It is an error if a REQUIRED or POSITIONAL parameter follows a | |
15343 * NAMED parameter. | |
15344 * | |
15345 * - To change the order and/or update proposed parameters, add parameters | |
15346 * with the same identifiers as proposed. | |
15347 * - To add new parameters, omit their identifier. | |
15348 * - To remove some parameters, omit them in this list. | |
15349 */ | |
15350 List<RefactoringMethodParameter> get parameters => _parameters; | |
15351 | |
15352 /** | |
15353 * The parameters that should be defined for the method. | |
15354 * | |
15355 * It is an error if a REQUIRED or NAMED parameter follows a POSITIONAL | |
15356 * parameter. It is an error if a REQUIRED or POSITIONAL parameter follows a | |
15357 * NAMED parameter. | |
15358 * | |
15359 * - To change the order and/or update proposed parameters, add parameters | |
15360 * with the same identifiers as proposed. | |
15361 * - To add new parameters, omit their identifier. | |
15362 * - To remove some parameters, omit them in this list. | |
15363 */ | |
15364 void set parameters(List<RefactoringMethodParameter> value) { | |
15365 assert(value != null); | |
15366 this._parameters = value; | |
15367 } | |
15368 | |
15369 /** | |
15370 * True if all occurrences of the expression or statements should be replaced | |
15371 * by an invocation of the method. The expression or statements used to | |
15372 * initiate the refactoring will always be replaced. | |
15373 */ | |
15374 bool get extractAll => _extractAll; | |
15375 | |
15376 /** | |
15377 * True if all occurrences of the expression or statements should be replaced | |
15378 * by an invocation of the method. The expression or statements used to | |
15379 * initiate the refactoring will always be replaced. | |
15380 */ | |
15381 void set extractAll(bool value) { | |
15382 assert(value != null); | |
15383 this._extractAll = value; | |
15384 } | |
15385 | |
15386 ExtractMethodOptions(String returnType, bool createGetter, String name, List<R
efactoringMethodParameter> parameters, bool extractAll) { | |
15387 this.returnType = returnType; | |
15388 this.createGetter = createGetter; | |
15389 this.name = name; | |
15390 this.parameters = parameters; | |
15391 this.extractAll = extractAll; | |
15392 } | |
15393 | |
15394 factory ExtractMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath
, Object json) { | |
15395 if (json == null) { | |
15396 json = {}; | |
15397 } | |
15398 if (json is Map) { | |
15399 String returnType; | |
15400 if (json.containsKey("returnType")) { | |
15401 returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["r
eturnType"]); | |
15402 } else { | |
15403 throw jsonDecoder.missingKey(jsonPath, "returnType"); | |
15404 } | |
15405 bool createGetter; | |
15406 if (json.containsKey("createGetter")) { | |
15407 createGetter = jsonDecoder._decodeBool(jsonPath + ".createGetter", json[
"createGetter"]); | |
15408 } else { | |
15409 throw jsonDecoder.missingKey(jsonPath, "createGetter"); | |
15410 } | |
15411 String name; | |
15412 if (json.containsKey("name")) { | |
15413 name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]); | |
15414 } else { | |
15415 throw jsonDecoder.missingKey(jsonPath, "name"); | |
15416 } | |
15417 List<RefactoringMethodParameter> parameters; | |
15418 if (json.containsKey("parameters")) { | |
15419 parameters = jsonDecoder._decodeList(jsonPath + ".parameters", json["par
ameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.from
Json(jsonDecoder, jsonPath, json)); | |
15420 } else { | |
15421 throw jsonDecoder.missingKey(jsonPath, "parameters"); | |
15422 } | |
15423 bool extractAll; | |
15424 if (json.containsKey("extractAll")) { | |
15425 extractAll = jsonDecoder._decodeBool(jsonPath + ".extractAll", json["ext
ractAll"]); | |
15426 } else { | |
15427 throw jsonDecoder.missingKey(jsonPath, "extractAll"); | |
15428 } | |
15429 return new ExtractMethodOptions(returnType, createGetter, name, parameters
, extractAll); | |
15430 } else { | |
15431 throw jsonDecoder.mismatch(jsonPath, "extractMethod options", json); | |
15432 } | |
15433 } | |
15434 | |
15435 factory ExtractMethodOptions.fromRefactoringParams(EditGetRefactoringParams re
factoringParams, Request request) { | |
15436 return new ExtractMethodOptions.fromJson( | |
15437 new RequestDecoder(request), "options", refactoringParams.options); | |
15438 } | |
15439 | |
15440 Map<String, dynamic> toJson() { | |
15441 Map<String, dynamic> result = {}; | |
15442 result["returnType"] = returnType; | |
15443 result["createGetter"] = createGetter; | |
15444 result["name"] = name; | |
15445 result["parameters"] = parameters.map((RefactoringMethodParameter value) =>
value.toJson()).toList(); | |
15446 result["extractAll"] = extractAll; | |
15447 return result; | |
15448 } | |
15449 | |
15450 @override | |
15451 String toString() => JSON.encode(toJson()); | |
15452 | |
15453 @override | |
15454 bool operator==(other) { | |
15455 if (other is ExtractMethodOptions) { | |
15456 return returnType == other.returnType && | |
15457 createGetter == other.createGetter && | |
15458 name == other.name && | |
15459 _listEqual(parameters, other.parameters, (RefactoringMethodParameter a
, RefactoringMethodParameter b) => a == b) && | |
15460 extractAll == other.extractAll; | |
15461 } | |
15462 return false; | |
15463 } | |
15464 | |
15465 @override | |
15466 int get hashCode { | |
15467 int hash = 0; | |
15468 hash = _JenkinsSmiHash.combine(hash, returnType.hashCode); | |
15469 hash = _JenkinsSmiHash.combine(hash, createGetter.hashCode); | |
15470 hash = _JenkinsSmiHash.combine(hash, name.hashCode); | |
15471 hash = _JenkinsSmiHash.combine(hash, parameters.hashCode); | |
15472 hash = _JenkinsSmiHash.combine(hash, extractAll.hashCode); | |
15473 return _JenkinsSmiHash.finish(hash); | |
15474 } | |
15475 } | |
15476 | |
15477 /** | |
15478 * inlineLocalVariable feedback | |
15479 * | |
15480 * { | |
15481 * "name": String | |
15482 * "occurrences": int | |
15483 * } | |
15484 */ | |
15485 class InlineLocalVariableFeedback extends RefactoringFeedback implements HasToJs
on { | |
15486 String _name; | |
15487 | |
15488 int _occurrences; | |
15489 | |
15490 /** | |
15491 * The name of the variable being inlined. | |
15492 */ | |
15493 String get name => _name; | |
15494 | |
15495 /** | |
15496 * The name of the variable being inlined. | |
15497 */ | |
15498 void set name(String value) { | |
15499 assert(value != null); | |
15500 this._name = value; | |
15501 } | |
15502 | |
15503 /** | |
15504 * The number of times the variable occurs. | |
15505 */ | |
15506 int get occurrences => _occurrences; | |
15507 | |
15508 /** | |
15509 * The number of times the variable occurs. | |
15510 */ | |
15511 void set occurrences(int value) { | |
15512 assert(value != null); | |
15513 this._occurrences = value; | |
15514 } | |
15515 | |
15516 InlineLocalVariableFeedback(String name, int occurrences) { | |
15517 this.name = name; | |
15518 this.occurrences = occurrences; | |
15519 } | |
15520 | |
15521 factory InlineLocalVariableFeedback.fromJson(JsonDecoder jsonDecoder, String j
sonPath, Object json) { | |
15522 if (json == null) { | |
15523 json = {}; | |
15524 } | |
15525 if (json is Map) { | |
15526 String name; | |
15527 if (json.containsKey("name")) { | |
15528 name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]); | |
15529 } else { | |
15530 throw jsonDecoder.missingKey(jsonPath, "name"); | |
15531 } | |
15532 int occurrences; | |
15533 if (json.containsKey("occurrences")) { | |
15534 occurrences = jsonDecoder._decodeInt(jsonPath + ".occurrences", json["oc
currences"]); | |
15535 } else { | |
15536 throw jsonDecoder.missingKey(jsonPath, "occurrences"); | |
15537 } | |
15538 return new InlineLocalVariableFeedback(name, occurrences); | |
15539 } else { | |
15540 throw jsonDecoder.mismatch(jsonPath, "inlineLocalVariable feedback", json)
; | |
15541 } | |
15542 } | |
15543 | |
15544 Map<String, dynamic> toJson() { | |
15545 Map<String, dynamic> result = {}; | |
15546 result["name"] = name; | |
15547 result["occurrences"] = occurrences; | |
15548 return result; | |
15549 } | |
15550 | |
15551 @override | |
15552 String toString() => JSON.encode(toJson()); | |
15553 | |
15554 @override | |
15555 bool operator==(other) { | |
15556 if (other is InlineLocalVariableFeedback) { | |
15557 return name == other.name && | |
15558 occurrences == other.occurrences; | |
15559 } | |
15560 return false; | |
15561 } | |
15562 | |
15563 @override | |
15564 int get hashCode { | |
15565 int hash = 0; | |
15566 hash = _JenkinsSmiHash.combine(hash, name.hashCode); | |
15567 hash = _JenkinsSmiHash.combine(hash, occurrences.hashCode); | |
15568 return _JenkinsSmiHash.finish(hash); | |
15569 } | |
15570 } | |
15571 /** | |
15572 * inlineLocalVariable options | |
15573 */ | |
15574 class InlineLocalVariableOptions { | |
15575 @override | |
15576 bool operator==(other) { | |
15577 if (other is InlineLocalVariableOptions) { | |
15578 return true; | |
15579 } | |
15580 return false; | |
15581 } | |
15582 | |
15583 @override | |
15584 int get hashCode { | |
15585 return 540364977; | |
15586 } | |
15587 } | |
15588 | |
15589 /** | |
15590 * inlineMethod feedback | |
15591 * | |
15592 * { | |
15593 * "className": optional String | |
15594 * "methodName": String | |
15595 * "isDeclaration": bool | |
15596 * } | |
15597 */ | |
15598 class InlineMethodFeedback extends RefactoringFeedback implements HasToJson { | |
15599 String _className; | |
15600 | |
15601 String _methodName; | |
15602 | |
15603 bool _isDeclaration; | |
15604 | |
15605 /** | |
15606 * The name of the class enclosing the method being inlined. If not a class | |
15607 * member is being inlined, this field will be absent. | |
15608 */ | |
15609 String get className => _className; | |
15610 | |
15611 /** | |
15612 * The name of the class enclosing the method being inlined. If not a class | |
15613 * member is being inlined, this field will be absent. | |
15614 */ | |
15615 void set className(String value) { | |
15616 this._className = value; | |
15617 } | |
15618 | |
15619 /** | |
15620 * The name of the method (or function) being inlined. | |
15621 */ | |
15622 String get methodName => _methodName; | |
15623 | |
15624 /** | |
15625 * The name of the method (or function) being inlined. | |
15626 */ | |
15627 void set methodName(String value) { | |
15628 assert(value != null); | |
15629 this._methodName = value; | |
15630 } | |
15631 | |
15632 /** | |
15633 * True if the declaration of the method is selected. So all references | |
15634 * should be inlined. | |
15635 */ | |
15636 bool get isDeclaration => _isDeclaration; | |
15637 | |
15638 /** | |
15639 * True if the declaration of the method is selected. So all references | |
15640 * should be inlined. | |
15641 */ | |
15642 void set isDeclaration(bool value) { | |
15643 assert(value != null); | |
15644 this._isDeclaration = value; | |
15645 } | |
15646 | |
15647 InlineMethodFeedback(String methodName, bool isDeclaration, {String className}
) { | |
15648 this.className = className; | |
15649 this.methodName = methodName; | |
15650 this.isDeclaration = isDeclaration; | |
15651 } | |
15652 | |
15653 factory InlineMethodFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath
, Object json) { | |
15654 if (json == null) { | |
15655 json = {}; | |
15656 } | |
15657 if (json is Map) { | |
15658 String className; | |
15659 if (json.containsKey("className")) { | |
15660 className = jsonDecoder._decodeString(jsonPath + ".className", json["cla
ssName"]); | |
15661 } | |
15662 String methodName; | |
15663 if (json.containsKey("methodName")) { | |
15664 methodName = jsonDecoder._decodeString(jsonPath + ".methodName", json["m
ethodName"]); | |
15665 } else { | |
15666 throw jsonDecoder.missingKey(jsonPath, "methodName"); | |
15667 } | |
15668 bool isDeclaration; | |
15669 if (json.containsKey("isDeclaration")) { | |
15670 isDeclaration = jsonDecoder._decodeBool(jsonPath + ".isDeclaration", jso
n["isDeclaration"]); | |
15671 } else { | |
15672 throw jsonDecoder.missingKey(jsonPath, "isDeclaration"); | |
15673 } | |
15674 return new InlineMethodFeedback(methodName, isDeclaration, className: clas
sName); | |
15675 } else { | |
15676 throw jsonDecoder.mismatch(jsonPath, "inlineMethod feedback", json); | |
15677 } | |
15678 } | |
15679 | |
15680 Map<String, dynamic> toJson() { | |
15681 Map<String, dynamic> result = {}; | |
15682 if (className != null) { | |
15683 result["className"] = className; | |
15684 } | |
15685 result["methodName"] = methodName; | |
15686 result["isDeclaration"] = isDeclaration; | |
15687 return result; | |
15688 } | |
15689 | |
15690 @override | |
15691 String toString() => JSON.encode(toJson()); | |
15692 | |
15693 @override | |
15694 bool operator==(other) { | |
15695 if (other is InlineMethodFeedback) { | |
15696 return className == other.className && | |
15697 methodName == other.methodName && | |
15698 isDeclaration == other.isDeclaration; | |
15699 } | |
15700 return false; | |
15701 } | |
15702 | |
15703 @override | |
15704 int get hashCode { | |
15705 int hash = 0; | |
15706 hash = _JenkinsSmiHash.combine(hash, className.hashCode); | |
15707 hash = _JenkinsSmiHash.combine(hash, methodName.hashCode); | |
15708 hash = _JenkinsSmiHash.combine(hash, isDeclaration.hashCode); | |
15709 return _JenkinsSmiHash.finish(hash); | |
15710 } | |
15711 } | |
15712 | |
15713 /** | |
15714 * inlineMethod options | |
15715 * | |
15716 * { | |
15717 * "deleteSource": bool | |
15718 * "inlineAll": bool | |
15719 * } | |
15720 */ | |
15721 class InlineMethodOptions extends RefactoringOptions implements HasToJson { | |
15722 bool _deleteSource; | |
15723 | |
15724 bool _inlineAll; | |
15725 | |
15726 /** | |
15727 * True if the method being inlined should be removed. It is an error if this | |
15728 * field is true and inlineAll is false. | |
15729 */ | |
15730 bool get deleteSource => _deleteSource; | |
15731 | |
15732 /** | |
15733 * True if the method being inlined should be removed. It is an error if this | |
15734 * field is true and inlineAll is false. | |
15735 */ | |
15736 void set deleteSource(bool value) { | |
15737 assert(value != null); | |
15738 this._deleteSource = value; | |
15739 } | |
15740 | |
15741 /** | |
15742 * True if all invocations of the method should be inlined, or false if only | |
15743 * the invocation site used to create this refactoring should be inlined. | |
15744 */ | |
15745 bool get inlineAll => _inlineAll; | |
15746 | |
15747 /** | |
15748 * True if all invocations of the method should be inlined, or false if only | |
15749 * the invocation site used to create this refactoring should be inlined. | |
15750 */ | |
15751 void set inlineAll(bool value) { | |
15752 assert(value != null); | |
15753 this._inlineAll = value; | |
15754 } | |
15755 | |
15756 InlineMethodOptions(bool deleteSource, bool inlineAll) { | |
15757 this.deleteSource = deleteSource; | |
15758 this.inlineAll = inlineAll; | |
15759 } | |
15760 | |
15761 factory InlineMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath,
Object json) { | |
15762 if (json == null) { | |
15763 json = {}; | |
15764 } | |
15765 if (json is Map) { | |
15766 bool deleteSource; | |
15767 if (json.containsKey("deleteSource")) { | |
15768 deleteSource = jsonDecoder._decodeBool(jsonPath + ".deleteSource", json[
"deleteSource"]); | |
15769 } else { | |
15770 throw jsonDecoder.missingKey(jsonPath, "deleteSource"); | |
15771 } | |
15772 bool inlineAll; | |
15773 if (json.containsKey("inlineAll")) { | |
15774 inlineAll = jsonDecoder._decodeBool(jsonPath + ".inlineAll", json["inlin
eAll"]); | |
15775 } else { | |
15776 throw jsonDecoder.missingKey(jsonPath, "inlineAll"); | |
15777 } | |
15778 return new InlineMethodOptions(deleteSource, inlineAll); | |
15779 } else { | |
15780 throw jsonDecoder.mismatch(jsonPath, "inlineMethod options", json); | |
15781 } | |
15782 } | |
15783 | |
15784 factory InlineMethodOptions.fromRefactoringParams(EditGetRefactoringParams ref
actoringParams, Request request) { | |
15785 return new InlineMethodOptions.fromJson( | |
15786 new RequestDecoder(request), "options", refactoringParams.options); | |
15787 } | |
15788 | |
15789 Map<String, dynamic> toJson() { | |
15790 Map<String, dynamic> result = {}; | |
15791 result["deleteSource"] = deleteSource; | |
15792 result["inlineAll"] = inlineAll; | |
15793 return result; | |
15794 } | |
15795 | |
15796 @override | |
15797 String toString() => JSON.encode(toJson()); | |
15798 | |
15799 @override | |
15800 bool operator==(other) { | |
15801 if (other is InlineMethodOptions) { | |
15802 return deleteSource == other.deleteSource && | |
15803 inlineAll == other.inlineAll; | |
15804 } | |
15805 return false; | |
15806 } | |
15807 | |
15808 @override | |
15809 int get hashCode { | |
15810 int hash = 0; | |
15811 hash = _JenkinsSmiHash.combine(hash, deleteSource.hashCode); | |
15812 hash = _JenkinsSmiHash.combine(hash, inlineAll.hashCode); | |
15813 return _JenkinsSmiHash.finish(hash); | |
15814 } | |
15815 } | |
15816 /** | |
15817 * moveFile feedback | |
15818 */ | |
15819 class MoveFileFeedback { | |
15820 @override | |
15821 bool operator==(other) { | |
15822 if (other is MoveFileFeedback) { | |
15823 return true; | |
15824 } | |
15825 return false; | |
15826 } | |
15827 | |
15828 @override | |
15829 int get hashCode { | |
15830 return 438975893; | |
15831 } | |
15832 } | |
15833 | |
15834 /** | |
15835 * moveFile options | |
15836 * | |
15837 * { | |
15838 * "newFile": FilePath | |
15839 * } | |
15840 */ | |
15841 class MoveFileOptions extends RefactoringOptions implements HasToJson { | |
15842 String _newFile; | |
15843 | |
15844 /** | |
15845 * The new file path to which the given file is being moved. | |
15846 */ | |
15847 String get newFile => _newFile; | |
15848 | |
15849 /** | |
15850 * The new file path to which the given file is being moved. | |
15851 */ | |
15852 void set newFile(String value) { | |
15853 assert(value != null); | |
15854 this._newFile = value; | |
15855 } | |
15856 | |
15857 MoveFileOptions(String newFile) { | |
15858 this.newFile = newFile; | |
15859 } | |
15860 | |
15861 factory MoveFileOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obj
ect json) { | |
15862 if (json == null) { | |
15863 json = {}; | |
15864 } | |
15865 if (json is Map) { | |
15866 String newFile; | |
15867 if (json.containsKey("newFile")) { | |
15868 newFile = jsonDecoder._decodeString(jsonPath + ".newFile", json["newFile
"]); | |
15869 } else { | |
15870 throw jsonDecoder.missingKey(jsonPath, "newFile"); | |
15871 } | |
15872 return new MoveFileOptions(newFile); | |
15873 } else { | |
15874 throw jsonDecoder.mismatch(jsonPath, "moveFile options", json); | |
15875 } | |
15876 } | |
15877 | |
15878 factory MoveFileOptions.fromRefactoringParams(EditGetRefactoringParams refacto
ringParams, Request request) { | |
15879 return new MoveFileOptions.fromJson( | |
15880 new RequestDecoder(request), "options", refactoringParams.options); | |
15881 } | |
15882 | |
15883 Map<String, dynamic> toJson() { | |
15884 Map<String, dynamic> result = {}; | |
15885 result["newFile"] = newFile; | |
15886 return result; | |
15887 } | |
15888 | |
15889 @override | |
15890 String toString() => JSON.encode(toJson()); | |
15891 | |
15892 @override | |
15893 bool operator==(other) { | |
15894 if (other is MoveFileOptions) { | |
15895 return newFile == other.newFile; | |
15896 } | |
15897 return false; | |
15898 } | |
15899 | |
15900 @override | |
15901 int get hashCode { | |
15902 int hash = 0; | |
15903 hash = _JenkinsSmiHash.combine(hash, newFile.hashCode); | |
15904 return _JenkinsSmiHash.finish(hash); | |
15905 } | |
15906 } | |
15907 | |
15908 /** | |
15909 * rename feedback | |
15910 * | |
15911 * { | |
15912 * "offset": int | |
15913 * "length": int | |
15914 * "elementKindName": String | |
15915 * "oldName": String | |
15916 * } | |
15917 */ | |
15918 class RenameFeedback extends RefactoringFeedback implements HasToJson { | |
15919 int _offset; | |
15920 | |
15921 int _length; | |
15922 | |
15923 String _elementKindName; | |
15924 | |
15925 String _oldName; | |
15926 | |
15927 /** | |
15928 * The offset to the beginning of the name selected to be renamed. | |
15929 */ | |
15930 int get offset => _offset; | |
15931 | |
15932 /** | |
15933 * The offset to the beginning of the name selected to be renamed. | |
15934 */ | |
15935 void set offset(int value) { | |
15936 assert(value != null); | |
15937 this._offset = value; | |
15938 } | |
15939 | |
15940 /** | |
15941 * The length of the name selected to be renamed. | |
15942 */ | |
15943 int get length => _length; | |
15944 | |
15945 /** | |
15946 * The length of the name selected to be renamed. | |
15947 */ | |
15948 void set length(int value) { | |
15949 assert(value != null); | |
15950 this._length = value; | |
15951 } | |
15952 | |
15953 /** | |
15954 * The human-readable description of the kind of element being renamed (such | |
15955 * as “class” or “function type alias”). | |
15956 */ | |
15957 String get elementKindName => _elementKindName; | |
15958 | |
15959 /** | |
15960 * The human-readable description of the kind of element being renamed (such | |
15961 * as “class” or “function type alias”). | |
15962 */ | |
15963 void set elementKindName(String value) { | |
15964 assert(value != null); | |
15965 this._elementKindName = value; | |
15966 } | |
15967 | |
15968 /** | |
15969 * The old name of the element before the refactoring. | |
15970 */ | |
15971 String get oldName => _oldName; | |
15972 | |
15973 /** | |
15974 * The old name of the element before the refactoring. | |
15975 */ | |
15976 void set oldName(String value) { | |
15977 assert(value != null); | |
15978 this._oldName = value; | |
15979 } | |
15980 | |
15981 RenameFeedback(int offset, int length, String elementKindName, String oldName)
{ | |
15982 this.offset = offset; | |
15983 this.length = length; | |
15984 this.elementKindName = elementKindName; | |
15985 this.oldName = oldName; | |
15986 } | |
15987 | |
15988 factory RenameFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obje
ct json) { | |
15989 if (json == null) { | |
15990 json = {}; | |
15991 } | |
15992 if (json is Map) { | |
15993 int offset; | |
15994 if (json.containsKey("offset")) { | |
15995 offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]); | |
15996 } else { | |
15997 throw jsonDecoder.missingKey(jsonPath, "offset"); | |
15998 } | |
15999 int length; | |
16000 if (json.containsKey("length")) { | |
16001 length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]); | |
16002 } else { | |
16003 throw jsonDecoder.missingKey(jsonPath, "length"); | |
16004 } | |
16005 String elementKindName; | |
16006 if (json.containsKey("elementKindName")) { | |
16007 elementKindName = jsonDecoder._decodeString(jsonPath + ".elementKindName
", json["elementKindName"]); | |
16008 } else { | |
16009 throw jsonDecoder.missingKey(jsonPath, "elementKindName"); | |
16010 } | |
16011 String oldName; | |
16012 if (json.containsKey("oldName")) { | |
16013 oldName = jsonDecoder._decodeString(jsonPath + ".oldName", json["oldName
"]); | |
16014 } else { | |
16015 throw jsonDecoder.missingKey(jsonPath, "oldName"); | |
16016 } | |
16017 return new RenameFeedback(offset, length, elementKindName, oldName); | |
16018 } else { | |
16019 throw jsonDecoder.mismatch(jsonPath, "rename feedback", json); | |
16020 } | |
16021 } | |
16022 | |
16023 Map<String, dynamic> toJson() { | |
16024 Map<String, dynamic> result = {}; | |
16025 result["offset"] = offset; | |
16026 result["length"] = length; | |
16027 result["elementKindName"] = elementKindName; | |
16028 result["oldName"] = oldName; | |
16029 return result; | |
16030 } | |
16031 | |
16032 @override | |
16033 String toString() => JSON.encode(toJson()); | |
16034 | |
16035 @override | |
16036 bool operator==(other) { | |
16037 if (other is RenameFeedback) { | |
16038 return offset == other.offset && | |
16039 length == other.length && | |
16040 elementKindName == other.elementKindName && | |
16041 oldName == other.oldName; | |
16042 } | |
16043 return false; | |
16044 } | |
16045 | |
16046 @override | |
16047 int get hashCode { | |
16048 int hash = 0; | |
16049 hash = _JenkinsSmiHash.combine(hash, offset.hashCode); | |
16050 hash = _JenkinsSmiHash.combine(hash, length.hashCode); | |
16051 hash = _JenkinsSmiHash.combine(hash, elementKindName.hashCode); | |
16052 hash = _JenkinsSmiHash.combine(hash, oldName.hashCode); | |
16053 return _JenkinsSmiHash.finish(hash); | |
16054 } | |
16055 } | |
16056 | |
16057 /** | |
16058 * rename options | |
16059 * | |
16060 * { | |
16061 * "newName": String | |
16062 * } | |
16063 */ | |
16064 class RenameOptions extends RefactoringOptions implements HasToJson { | |
16065 String _newName; | |
16066 | |
16067 /** | |
16068 * The name that the element should have after the refactoring. | |
16069 */ | |
16070 String get newName => _newName; | |
16071 | |
16072 /** | |
16073 * The name that the element should have after the refactoring. | |
16074 */ | |
16075 void set newName(String value) { | |
16076 assert(value != null); | |
16077 this._newName = value; | |
16078 } | |
16079 | |
16080 RenameOptions(String newName) { | |
16081 this.newName = newName; | |
16082 } | |
16083 | |
16084 factory RenameOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Objec
t json) { | |
16085 if (json == null) { | |
16086 json = {}; | |
16087 } | |
16088 if (json is Map) { | |
16089 String newName; | |
16090 if (json.containsKey("newName")) { | |
16091 newName = jsonDecoder._decodeString(jsonPath + ".newName", json["newName
"]); | |
16092 } else { | |
16093 throw jsonDecoder.missingKey(jsonPath, "newName"); | |
16094 } | |
16095 return new RenameOptions(newName); | |
16096 } else { | |
16097 throw jsonDecoder.mismatch(jsonPath, "rename options", json); | |
16098 } | |
16099 } | |
16100 | |
16101 factory RenameOptions.fromRefactoringParams(EditGetRefactoringParams refactori
ngParams, Request request) { | |
16102 return new RenameOptions.fromJson( | |
16103 new RequestDecoder(request), "options", refactoringParams.options); | |
16104 } | |
16105 | |
16106 Map<String, dynamic> toJson() { | |
16107 Map<String, dynamic> result = {}; | |
16108 result["newName"] = newName; | |
16109 return result; | |
16110 } | |
16111 | |
16112 @override | |
16113 String toString() => JSON.encode(toJson()); | |
16114 | |
16115 @override | |
16116 bool operator==(other) { | |
16117 if (other is RenameOptions) { | |
16118 return newName == other.newName; | |
16119 } | |
16120 return false; | |
16121 } | |
16122 | |
16123 @override | |
16124 int get hashCode { | |
16125 int hash = 0; | |
16126 hash = _JenkinsSmiHash.combine(hash, newName.hashCode); | |
16127 return _JenkinsSmiHash.finish(hash); | |
16128 } | |
16129 } | |
OLD | NEW |