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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: pkg/compiler/lib/src/resolution/semantic_visitor_mixins.dart

Issue 1142293004: Revert "Refactor handling of compounds." (Closed) Base URL: https://github.com/dart-lang/sdk.git@master
Patch Set: Created 5 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « pkg/compiler/lib/src/resolution/semantic_visitor.dart ('k') | pkg/compiler/lib/src/resolution/send_resolver.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file 1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
2 // for details. All rights reserved. Use of this source code is governed by a 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. 3 // BSD-style license that can be found in the LICENSE file.
4 4
5 part of dart2js.semantics_visitor; 5 part of dart2js.semantics_visitor;
6 6
7 /// Interface for bulk handling of a [Node] in a semantic visitor. 7 /// Interface for bulk handling of a [Node] in a semantic visitor.
8 abstract class BulkHandle<R, A> { 8 abstract class BulkHandle<R, A> {
9 /// Handle [node] either regardless of semantics or to report that [node] is 9 /// Handle [node] either regardless of semantics or to report that [node] is
10 /// unhandled. [message] contains a message template for the latter case: 10 /// unhandled. [message] contains a message template for the latter case:
(...skipping 15 matching lines...) Expand all
26 26
27 @override 27 @override
28 R errorInvalidAssert( 28 R errorInvalidAssert(
29 Send node, 29 Send node,
30 NodeList arguments, 30 NodeList arguments,
31 A arg) { 31 A arg) {
32 return bulkHandleError(node, arg); 32 return bulkHandleError(node, arg);
33 } 33 }
34 34
35 @override 35 @override
36 R errorClassTypeLiteralCompound(
37 Send node,
38 ConstantExpression constant,
39 AssignmentOperator operator,
40 Node rhs,
41 A arg) {
42 return bulkHandleError(node, arg);
43 }
44
45 @override
46 R errorClassTypeLiteralPostfix(
47 Send node,
48 ConstantExpression constant,
49 IncDecOperator operator,
50 A arg) {
51 return bulkHandleError(node, arg);
52 }
53
54 @override
55 R errorClassTypeLiteralPrefix(
56 Send node,
57 ConstantExpression constant,
58 IncDecOperator operator,
59 A arg) {
60 return bulkHandleError(node, arg);
61 }
62
63 @override
36 R errorClassTypeLiteralSet( 64 R errorClassTypeLiteralSet(
37 SendSet node, 65 SendSet node,
38 ConstantExpression constant, 66 ConstantExpression constant,
39 Node rhs, 67 Node rhs,
40 A arg) { 68 A arg) {
41 return bulkHandleError(node, arg); 69 return bulkHandleError(node, arg);
42 } 70 }
43 71
44 @override 72 @override
73 R errorDynamicTypeLiteralCompound(
74 Send node,
75 ConstantExpression constant,
76 AssignmentOperator operator,
77 Node rhs,
78 A arg) {
79 return bulkHandleError(node, arg);
80 }
81
82 @override
83 R errorDynamicTypeLiteralPostfix(
84 Send node,
85 ConstantExpression constant,
86 IncDecOperator operator,
87 A arg) {
88 return bulkHandleError(node, arg);
89 }
90
91 @override
92 R errorDynamicTypeLiteralPrefix(
93 Send node,
94 ConstantExpression constant,
95 IncDecOperator operator,
96 A arg) {
97 return bulkHandleError(node, arg);
98 }
99
100 @override
45 R errorDynamicTypeLiteralSet( 101 R errorDynamicTypeLiteralSet(
46 SendSet node, 102 SendSet node,
47 ConstantExpression constant, 103 ConstantExpression constant,
48 Node rhs, 104 Node rhs,
49 A arg) { 105 A arg) {
50 return bulkHandleError(node, arg); 106 return bulkHandleError(node, arg);
51 } 107 }
52 108
53 @override 109 @override
110 R errorFinalLocalVariableCompound(
111 Send node,
112 LocalVariableElement
113 variable,
114 AssignmentOperator operator,
115 Node rhs,
116 A arg) {
117 return bulkHandleError(node, arg);
118 }
119
120 @override
54 R errorFinalLocalVariableSet( 121 R errorFinalLocalVariableSet(
55 SendSet node, 122 SendSet node,
56 LocalVariableElement variable, 123 LocalVariableElement variable,
57 Node rhs, 124 Node rhs,
58 A arg) { 125 A arg) {
59 return bulkHandleError(node, arg); 126 return bulkHandleError(node, arg);
60 } 127 }
61 128
62 @override 129 @override
130 R errorFinalParameterCompound(
131 Send node,
132 ParameterElement parameter,
133 AssignmentOperator operator,
134 Node rhs,
135 A arg) {
136 return bulkHandleError(node, arg);
137 }
138
139 @override
63 R errorFinalParameterSet( 140 R errorFinalParameterSet(
64 SendSet node, 141 SendSet node,
65 ParameterElement parameter, 142 ParameterElement parameter,
66 Node rhs, 143 Node rhs,
67 A arg) { 144 A arg) {
68 return bulkHandleError(node, arg); 145 return bulkHandleError(node, arg);
69 } 146 }
70 147
71 @override 148 @override
149 R errorFinalStaticFieldCompound(
150 Send node,
151 FieldElement field,
152 AssignmentOperator operator,
153 Node rhs,
154 A arg) {
155 return bulkHandleError(node, arg);
156 }
157
158 @override
72 R errorFinalStaticFieldSet( 159 R errorFinalStaticFieldSet(
73 SendSet node, 160 SendSet node,
74 FieldElement field, 161 FieldElement field,
75 Node rhs, 162 Node rhs,
76 A arg) { 163 A arg) {
77 return bulkHandleError(node, arg); 164 return bulkHandleError(node, arg);
78 } 165 }
79 166
80 @override 167 @override
168 R errorFinalSuperFieldCompound(
169 Send node,
170 FieldElement field,
171 AssignmentOperator operator,
172 Node rhs,
173 A arg) {
174 return bulkHandleError(node, arg);
175 }
176
177 @override
81 R errorFinalSuperFieldSet( 178 R errorFinalSuperFieldSet(
82 SendSet node, 179 SendSet node,
83 FieldElement field, 180 FieldElement field,
84 Node rhs, 181 Node rhs,
85 A arg) { 182 A arg) {
86 return bulkHandleError(node, arg); 183 return bulkHandleError(node, arg);
87 } 184 }
88 185
89 @override 186 @override
187 R errorFinalTopLevelFieldCompound(
188 Send node,
189 FieldElement field,
190 AssignmentOperator operator,
191 Node rhs,
192 A arg) {
193 return bulkHandleError(node, arg);
194 }
195
196 @override
90 R errorFinalTopLevelFieldSet( 197 R errorFinalTopLevelFieldSet(
91 SendSet node, 198 SendSet node,
92 FieldElement field, 199 FieldElement field,
93 Node rhs, 200 Node rhs,
94 A arg) { 201 A arg) {
95 return bulkHandleError(node, arg); 202 return bulkHandleError(node, arg);
96 } 203 }
97 204
98 @override 205 @override
206 R errorLocalFunctionCompound(
207 Send node,
208 LocalFunctionElement function,
209 AssignmentOperator operator,
210 Node rhs,
211 A arg) {
212 return bulkHandleError(node, arg);
213 }
214
215 @override
216 R errorLocalFunctionPostfix(
217 Send node,
218 LocalFunctionElement function,
219 IncDecOperator operator,
220 A arg) {
221 return bulkHandleError(node, arg);
222 }
223
224 @override
225 R errorLocalFunctionPrefix(
226 Send node,
227 LocalFunctionElement function,
228 IncDecOperator operator,
229 A arg) {
230 return bulkHandleError(node, arg);
231 }
232
233 @override
99 R errorLocalFunctionSet( 234 R errorLocalFunctionSet(
100 SendSet node, 235 SendSet node,
101 LocalFunctionElement function, 236 LocalFunctionElement function,
102 Node rhs, 237 Node rhs,
103 A arg) { 238 A arg) {
104 return bulkHandleError(node, arg); 239 return bulkHandleError(node, arg);
105 } 240 }
106 241
107 @override 242 @override
108 R errorNonConstantConstructorInvoke( 243 R errorNonConstantConstructorInvoke(
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after
217 R errorTopLevelSetterInvoke( 352 R errorTopLevelSetterInvoke(
218 Send node, 353 Send node,
219 FunctionElement setter, 354 FunctionElement setter,
220 NodeList arguments, 355 NodeList arguments,
221 CallStructure callStructure, 356 CallStructure callStructure,
222 A arg) { 357 A arg) {
223 return bulkHandleError(node, arg); 358 return bulkHandleError(node, arg);
224 } 359 }
225 360
226 @override 361 @override
362 R errorTypeVariableTypeLiteralCompound(
363 Send node,
364 TypeVariableElement element,
365 AssignmentOperator operator,
366 Node rhs,
367 A arg) {
368 return bulkHandleError(node, arg);
369 }
370
371 @override
372 R errorTypeVariableTypeLiteralPostfix(
373 Send node,
374 TypeVariableElement element,
375 IncDecOperator operator,
376 A arg) {
377 return bulkHandleError(node, arg);
378 }
379
380 @override
381 R errorTypeVariableTypeLiteralPrefix(
382 Send node,
383 TypeVariableElement element,
384 IncDecOperator operator,
385 A arg) {
386 return bulkHandleError(node, arg);
387 }
388
389 @override
227 R errorTypeVariableTypeLiteralSet( 390 R errorTypeVariableTypeLiteralSet(
228 SendSet node, 391 SendSet node,
229 TypeVariableElement element, 392 TypeVariableElement element,
230 Node rhs, 393 Node rhs,
231 A arg) { 394 A arg) {
232 return bulkHandleError(node, arg); 395 return bulkHandleError(node, arg);
233 } 396 }
234 397
235 @override 398 @override
399 R errorTypedefTypeLiteralCompound(
400 Send node,
401 ConstantExpression constant,
402 AssignmentOperator operator,
403 Node rhs,
404 A arg) {
405 return bulkHandleError(node, arg);
406 }
407
408 @override
409 R errorTypedefTypeLiteralPostfix(
410 Send node,
411 ConstantExpression constant,
412 IncDecOperator operator,
413 A arg) {
414 return bulkHandleError(node, arg);
415 }
416
417 @override
418 R errorTypedefTypeLiteralPrefix(
419 Send node,
420 ConstantExpression constant,
421 IncDecOperator operator,
422 A arg) {
423 return bulkHandleError(node, arg);
424 }
425
426 @override
236 R errorTypedefTypeLiteralSet( 427 R errorTypedefTypeLiteralSet(
237 SendSet node, 428 SendSet node,
238 ConstantExpression constant, 429 ConstantExpression constant,
239 Node rhs, 430 Node rhs,
240 A arg) { 431 A arg) {
241 return bulkHandleError(node, arg); 432 return bulkHandleError(node, arg);
242 } 433 }
243 434
244 @override 435 @override
436 R errorUnresolvedCompound(
437 Send node,
438 Element element,
439 AssignmentOperator operator,
440 Node rhs,
441 A arg) {
442 return bulkHandleError(node, arg);
443 }
444
445 @override
446 R errorUnresolvedPostfix(
447 Send node,
448 Element element,
449 IncDecOperator operator,
450 A arg) {
451 return bulkHandleError(node, arg);
452 }
453
454 @override
455 R errorUnresolvedPrefix(
456 Send node,
457 Element element,
458 IncDecOperator operator,
459 A arg) {
460 return bulkHandleError(node, arg);
461 }
462
463 @override
245 R errorUnresolvedSet( 464 R errorUnresolvedSet(
246 Send node, 465 Send node,
247 Element element, 466 Element element,
248 Node rhs, 467 Node rhs,
249 A arg) { 468 A arg) {
250 return bulkHandleError(node, arg); 469 return bulkHandleError(node, arg);
251 } 470 }
252 471
253 @override 472 @override
254 R errorUndefinedUnaryExpression( 473 R errorUndefinedUnaryExpression(
(...skipping 152 matching lines...) Expand 10 before | Expand all | Expand 10 after
407 Node index, 626 Node index,
408 IncDecOperator operator, 627 IncDecOperator operator,
409 A arg) { 628 A arg) {
410 return bulkHandlePrefix(node, arg); 629 return bulkHandlePrefix(node, arg);
411 } 630 }
412 631
413 @override 632 @override
414 R visitUnresolvedSuperGetterIndexPrefix( 633 R visitUnresolvedSuperGetterIndexPrefix(
415 Send node, 634 Send node,
416 Element element, 635 Element element,
417 MethodElement setter,
418 Node index, 636 Node index,
419 IncDecOperator operator, 637 IncDecOperator operator,
420 A arg) { 638 A arg) {
421 return bulkHandlePrefix(node, arg); 639 return bulkHandlePrefix(node, arg);
422 } 640 }
423 641
424 @override 642 @override
425 R visitUnresolvedSuperSetterIndexPrefix( 643 R visitUnresolvedSuperSetterIndexPrefix(
426 Send node, 644 Send node,
427 MethodElement getter, 645 MethodElement getter,
428 Element element, 646 Element element,
429 Node index, 647 Node index,
430 IncDecOperator operator, 648 IncDecOperator operator,
431 A arg) { 649 A arg) {
432 return bulkHandlePrefix(node, arg); 650 return bulkHandlePrefix(node, arg);
433 } 651 }
434 652
435 @override 653 @override
436 R visitUnresolvedSuperIndexPrefix(
437 Send node,
438 Element element,
439 Node index,
440 IncDecOperator operator,
441 A arg) {
442 return bulkHandlePrefix(node, arg);
443 }
444
445 @override
446 R visitSuperMethodSetterPrefix( 654 R visitSuperMethodSetterPrefix(
447 Send node, 655 Send node,
448 FunctionElement method, 656 FunctionElement method,
449 FunctionElement setter, 657 FunctionElement setter,
450 IncDecOperator operator, 658 IncDecOperator operator,
451 A arg) { 659 A arg) {
452 return bulkHandlePrefix(node, arg); 660 return bulkHandlePrefix(node, arg);
453 } 661 }
454 662
455 @override 663 @override
(...skipping 27 matching lines...) Expand all
483 691
484 @override 692 @override
485 R visitTopLevelMethodSetterPrefix( 693 R visitTopLevelMethodSetterPrefix(
486 Send node, 694 Send node,
487 FunctionElement method, 695 FunctionElement method,
488 FunctionElement setter, 696 FunctionElement setter,
489 IncDecOperator operator, 697 IncDecOperator operator,
490 A arg) { 698 A arg) {
491 return bulkHandlePrefix(node, arg); 699 return bulkHandlePrefix(node, arg);
492 } 700 }
493
494 @override
495 R visitClassTypeLiteralPrefix(
496 Send node,
497 ConstantExpression constant,
498 IncDecOperator operator,
499 A arg) {
500 return bulkHandlePrefix(node, arg);
501 }
502
503 @override
504 R visitDynamicTypeLiteralPrefix(
505 Send node,
506 ConstantExpression constant,
507 IncDecOperator operator,
508 A arg) {
509 return bulkHandlePrefix(node, arg);
510 }
511
512 @override
513 R visitLocalFunctionPrefix(
514 Send node,
515 LocalFunctionElement function,
516 IncDecOperator operator,
517 A arg) {
518 return bulkHandlePrefix(node, arg);
519 }
520
521 @override
522 R visitTypeVariableTypeLiteralPrefix(
523 Send node,
524 TypeVariableElement element,
525 IncDecOperator operator,
526 A arg) {
527 return bulkHandlePrefix(node, arg);
528 }
529
530 @override
531 R visitTypedefTypeLiteralPrefix(
532 Send node,
533 ConstantExpression constant,
534 IncDecOperator operator,
535 A arg) {
536 return bulkHandlePrefix(node, arg);
537 }
538
539 @override
540 R visitUnresolvedStaticGetterPrefix(
541 Send node,
542 Element element,
543 MethodElement setter,
544 IncDecOperator operator,
545 A arg) {
546 return bulkHandlePrefix(node, arg);
547 }
548
549 @override
550 R visitUnresolvedTopLevelGetterPrefix(
551 Send node,
552 Element element,
553 MethodElement setter,
554 IncDecOperator operator,
555 A arg) {
556 return bulkHandlePrefix(node, arg);
557 }
558
559 @override
560 R visitUnresolvedStaticSetterPrefix(
561 Send node,
562 MethodElement getter,
563 Element element,
564 IncDecOperator operator,
565 A arg) {
566 return bulkHandlePrefix(node, arg);
567 }
568
569 @override
570 R visitUnresolvedTopLevelSetterPrefix(
571 Send node,
572 MethodElement getter,
573 Element element,
574 IncDecOperator operator,
575 A arg) {
576 return bulkHandlePrefix(node, arg);
577 }
578
579 @override
580 R visitStaticMethodPrefix(
581 Send node,
582 MethodElement method,
583 IncDecOperator operator,
584 A arg) {
585 return bulkHandlePrefix(node, arg);
586 }
587
588 @override
589 R visitTopLevelMethodPrefix(
590 Send node,
591 MethodElement method,
592 IncDecOperator operator,
593 A arg) {
594 return bulkHandlePrefix(node, arg);
595 }
596
597 @override
598 R visitUnresolvedPrefix(
599 Send node,
600 Element element,
601 IncDecOperator operator,
602 A arg) {
603 return bulkHandlePrefix(node, arg);
604 }
605
606 @override
607 R visitFinalLocalVariablePrefix(
608 Send node,
609 LocalVariableElement variable,
610 IncDecOperator operator,
611 A arg) {
612 return bulkHandlePrefix(node, arg);
613 }
614
615 @override
616 R visitFinalParameterPrefix(
617 Send node,
618 ParameterElement parameter,
619 IncDecOperator operator,
620 A arg) {
621 return bulkHandlePrefix(node, arg);
622 }
623
624 @override
625 R visitFinalStaticFieldPrefix(
626 Send node,
627 FieldElement field,
628 IncDecOperator operator,
629 A arg) {
630 return bulkHandlePrefix(node, arg);
631 }
632
633 @override
634 R visitFinalSuperFieldPrefix(
635 Send node,
636 FieldElement field,
637 IncDecOperator operator,
638 A arg) {
639 return bulkHandlePrefix(node, arg);
640 }
641
642 @override
643 R visitSuperMethodPrefix(
644 Send node,
645 FunctionElement method,
646 IncDecOperator operator,
647 A arg) {
648 return bulkHandlePrefix(node, arg);
649 }
650
651 @override
652 R visitFinalTopLevelFieldPrefix(
653 Send node,
654 FieldElement field,
655 IncDecOperator operator,
656 A arg) {
657 return bulkHandlePrefix(node, arg);
658 }
659
660 @override
661 R visitUnresolvedSuperPrefix(
662 Send node,
663 Element element,
664 IncDecOperator operator,
665 A arg) {
666 return bulkHandlePrefix(node, arg);
667 }
668
669 @override
670 R visitUnresolvedSuperGetterPrefix(
671 Send node,
672 Element element,
673 MethodElement setter,
674 IncDecOperator operator,
675 A arg) {
676 return bulkHandlePrefix(node, arg);
677 }
678
679 @override
680 R visitUnresolvedSuperSetterPrefix(
681 Send node,
682 MethodElement getter,
683 Element element,
684 IncDecOperator operator,
685 A arg) {
686 return bulkHandlePrefix(node, arg);
687 }
688 } 701 }
689 702
690 /// Mixin that implements all `visitXPostfix` methods of [SemanticSendVisitor] 703 /// Mixin that implements all `visitXPostfix` methods of [SemanticSendVisitor]
691 /// by delegating to a bulk handler. 704 /// by delegating to a bulk handler.
692 /// 705 ///
693 /// Use this mixin to provide a trivial implementation for all `visitXPostfix` 706 /// Use this mixin to provide a trivial implementation for all `visitXPostfix`
694 /// methods. 707 /// methods.
695 abstract class PostfixBulkMixin<R, A> 708 abstract class PostfixBulkMixin<R, A>
696 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 709 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
697 710
(...skipping 126 matching lines...) Expand 10 before | Expand all | Expand 10 after
824 Node index, 837 Node index,
825 IncDecOperator operator, 838 IncDecOperator operator,
826 A arg) { 839 A arg) {
827 return bulkHandlePostfix(node, arg); 840 return bulkHandlePostfix(node, arg);
828 } 841 }
829 842
830 @override 843 @override
831 R visitUnresolvedSuperGetterIndexPostfix( 844 R visitUnresolvedSuperGetterIndexPostfix(
832 Send node, 845 Send node,
833 Element element, 846 Element element,
834 MethodElement setter,
835 Node index, 847 Node index,
836 IncDecOperator operator, 848 IncDecOperator operator,
837 A arg) { 849 A arg) {
838 return bulkHandlePostfix(node, arg); 850 return bulkHandlePostfix(node, arg);
839 } 851 }
840 852
841 @override 853 @override
842 R visitUnresolvedSuperSetterIndexPostfix( 854 R visitUnresolvedSuperSetterIndexPostfix(
843 Send node, 855 Send node,
844 MethodElement getter, 856 MethodElement getter,
845 Element element, 857 Element element,
846 Node index, 858 Node index,
847 IncDecOperator operator, 859 IncDecOperator operator,
848 A arg) { 860 A arg) {
849 return bulkHandlePostfix(node, arg); 861 return bulkHandlePostfix(node, arg);
850 } 862 }
851 863
852 @override 864 @override
853 R visitUnresolvedSuperIndexPostfix(
854 Send node,
855 Element element,
856 Node index,
857 IncDecOperator operator,
858 A arg) {
859 return bulkHandlePostfix(node, arg);
860 }
861
862 @override
863 R visitSuperMethodSetterPostfix( 865 R visitSuperMethodSetterPostfix(
864 Send node, 866 Send node,
865 FunctionElement method, 867 FunctionElement method,
866 FunctionElement setter, 868 FunctionElement setter,
867 IncDecOperator operator, 869 IncDecOperator operator,
868 A arg) { 870 A arg) {
869 return bulkHandlePostfix(node, arg); 871 return bulkHandlePostfix(node, arg);
870 } 872 }
871 873
872 @override 874 @override
(...skipping 27 matching lines...) Expand all
900 902
901 @override 903 @override
902 R visitTopLevelMethodSetterPostfix( 904 R visitTopLevelMethodSetterPostfix(
903 Send node, 905 Send node,
904 FunctionElement method, 906 FunctionElement method,
905 FunctionElement setter, 907 FunctionElement setter,
906 IncDecOperator operator, 908 IncDecOperator operator,
907 A arg) { 909 A arg) {
908 return bulkHandlePostfix(node, arg); 910 return bulkHandlePostfix(node, arg);
909 } 911 }
910
911 @override
912 R visitClassTypeLiteralPostfix(
913 Send node,
914 ConstantExpression constant,
915 IncDecOperator operator,
916 A arg) {
917 return bulkHandlePostfix(node, arg);
918 }
919
920 @override
921 R visitDynamicTypeLiteralPostfix(
922 Send node,
923 ConstantExpression constant,
924 IncDecOperator operator,
925 A arg) {
926 return bulkHandlePostfix(node, arg);
927 }
928
929 @override
930 R visitLocalFunctionPostfix(
931 Send node,
932 LocalFunctionElement function,
933 IncDecOperator operator,
934 A arg) {
935 return bulkHandlePostfix(node, arg);
936 }
937
938 @override
939 R visitTypeVariableTypeLiteralPostfix(
940 Send node,
941 TypeVariableElement element,
942 IncDecOperator operator,
943 A arg) {
944 return bulkHandlePostfix(node, arg);
945 }
946
947 @override
948 R visitTypedefTypeLiteralPostfix(
949 Send node,
950 ConstantExpression constant,
951 IncDecOperator operator,
952 A arg) {
953 return bulkHandlePostfix(node, arg);
954 }
955
956 @override
957 R visitUnresolvedStaticGetterPostfix(
958 Send node,
959 Element element,
960 MethodElement setter,
961 IncDecOperator operator,
962 A arg) {
963 return bulkHandlePostfix(node, arg);
964 }
965
966 @override
967 R visitUnresolvedTopLevelGetterPostfix(
968 Send node,
969 Element element,
970 MethodElement setter,
971 IncDecOperator operator,
972 A arg) {
973 return bulkHandlePostfix(node, arg);
974 }
975
976 @override
977 R visitUnresolvedStaticSetterPostfix(
978 Send node,
979 MethodElement getter,
980 Element element,
981 IncDecOperator operator,
982 A arg) {
983 return bulkHandlePostfix(node, arg);
984 }
985
986 @override
987 R visitUnresolvedTopLevelSetterPostfix(
988 Send node,
989 MethodElement getter,
990 Element element,
991 IncDecOperator operator,
992 A arg) {
993 return bulkHandlePostfix(node, arg);
994 }
995
996 @override
997 R visitStaticMethodPostfix(
998 Send node,
999 MethodElement method,
1000 IncDecOperator operator,
1001 A arg) {
1002 return bulkHandlePostfix(node, arg);
1003 }
1004
1005 R visitToplevelMethodPostfix(
1006 Send node,
1007 MethodElement method,
1008 IncDecOperator operator,
1009 A arg) {
1010 return bulkHandlePostfix(node, arg);
1011 }
1012
1013 @override
1014 R visitUnresolvedPostfix(
1015 Send node,
1016 Element element,
1017 IncDecOperator operator,
1018 A arg) {
1019 return bulkHandlePostfix(node, arg);
1020 }
1021
1022 @override
1023 R visitFinalLocalVariablePostfix(
1024 Send node,
1025 LocalVariableElement variable,
1026 IncDecOperator operator,
1027 A arg) {
1028 return bulkHandlePostfix(node, arg);
1029 }
1030
1031 @override
1032 R visitFinalParameterPostfix(
1033 Send node,
1034 ParameterElement parameter,
1035 IncDecOperator operator,
1036 A arg) {
1037 return bulkHandlePostfix(node, arg);
1038 }
1039
1040 @override
1041 R visitFinalStaticFieldPostfix(
1042 Send node,
1043 FieldElement field,
1044 IncDecOperator operator,
1045 A arg) {
1046 return bulkHandlePostfix(node, arg);
1047 }
1048
1049 @override
1050 R visitFinalSuperFieldPostfix(
1051 Send node,
1052 FieldElement field,
1053 IncDecOperator operator,
1054 A arg) {
1055 return bulkHandlePostfix(node, arg);
1056 }
1057
1058 @override
1059 R visitSuperMethodPostfix(
1060 Send node,
1061 FunctionElement method,
1062 IncDecOperator operator,
1063 A arg) {
1064 return bulkHandlePostfix(node, arg);
1065 }
1066
1067 @override
1068 R visitFinalTopLevelFieldPostfix(
1069 Send node,
1070 FieldElement field,
1071 IncDecOperator operator,
1072 A arg) {
1073 return bulkHandlePostfix(node, arg);
1074 }
1075
1076 @override
1077 R visitTopLevelMethodPostfix(
1078 Send node,
1079 MethodElement method,
1080 IncDecOperator operator,
1081 A arg) {
1082 return bulkHandlePostfix(node, arg);
1083 }
1084
1085 @override
1086 R visitUnresolvedSuperPostfix(
1087 Send node,
1088 Element element,
1089 IncDecOperator operator,
1090 A arg) {
1091 return bulkHandlePostfix(node, arg);
1092 }
1093
1094 @override
1095 R visitUnresolvedSuperGetterPostfix(
1096 Send node,
1097 Element element,
1098 MethodElement setter,
1099 IncDecOperator operator,
1100 A arg) {
1101 return bulkHandlePostfix(node, arg);
1102 }
1103
1104 @override
1105 R visitUnresolvedSuperSetterPostfix(
1106 Send node,
1107 MethodElement getter,
1108 Element element,
1109 IncDecOperator operator,
1110 A arg) {
1111 return bulkHandlePostfix(node, arg);
1112 }
1113 } 912 }
1114 913
1115 /// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor] 914 /// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor]
1116 /// by delegating to a bulk handler. 915 /// by delegating to a bulk handler.
1117 /// 916 ///
1118 /// Use this mixin to provide a trivial implementation for all `xCompound` 917 /// Use this mixin to provide a trivial implementation for all `xCompound`
1119 /// methods. 918 /// methods.
1120 abstract class CompoundBulkMixin<R, A> 919 abstract class CompoundBulkMixin<R, A>
1121 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 920 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
1122 921
(...skipping 154 matching lines...) Expand 10 before | Expand all | Expand 10 after
1277 @override 1076 @override
1278 R visitTopLevelMethodSetterCompound( 1077 R visitTopLevelMethodSetterCompound(
1279 Send node, 1078 Send node,
1280 FunctionElement method, 1079 FunctionElement method,
1281 FunctionElement setter, 1080 FunctionElement setter,
1282 AssignmentOperator operator, 1081 AssignmentOperator operator,
1283 Node rhs, 1082 Node rhs,
1284 A arg) { 1083 A arg) {
1285 return bulkHandleCompound(node, arg); 1084 return bulkHandleCompound(node, arg);
1286 } 1085 }
1287
1288 @override
1289 R visitFinalParameterCompound(
1290 Send node,
1291 ParameterElement parameter,
1292 AssignmentOperator operator,
1293 Node rhs,
1294 A arg) {
1295 return bulkHandleCompound(node, arg);
1296 }
1297
1298 @override
1299 R visitClassTypeLiteralCompound(
1300 Send node,
1301 ConstantExpression constant,
1302 AssignmentOperator operator,
1303 Node rhs,
1304 A arg) {
1305 return bulkHandleCompound(node, arg);
1306 }
1307
1308 @override
1309 R visitDynamicTypeLiteralCompound(
1310 Send node,
1311 ConstantExpression constant,
1312 AssignmentOperator operator,
1313 Node rhs,
1314 A arg) {
1315 return bulkHandleCompound(node, arg);
1316 }
1317
1318 @override
1319 R visitFinalLocalVariableCompound(
1320 Send node,
1321 LocalVariableElement
1322 variable,
1323 AssignmentOperator operator,
1324 Node rhs,
1325 A arg) {
1326 return bulkHandleCompound(node, arg);
1327 }
1328
1329 @override
1330 R visitFinalStaticFieldCompound(
1331 Send node,
1332 FieldElement field,
1333 AssignmentOperator operator,
1334 Node rhs,
1335 A arg) {
1336 return bulkHandleCompound(node, arg);
1337 }
1338
1339 @override
1340 R visitFinalSuperFieldCompound(
1341 Send node,
1342 FieldElement field,
1343 AssignmentOperator operator,
1344 Node rhs,
1345 A arg) {
1346 return bulkHandleCompound(node, arg);
1347 }
1348
1349 @override
1350 R visitFinalTopLevelFieldCompound(
1351 Send node,
1352 FieldElement field,
1353 AssignmentOperator operator,
1354 Node rhs,
1355 A arg) {
1356 return bulkHandleCompound(node, arg);
1357 }
1358
1359 @override
1360 R visitLocalFunctionCompound(
1361 Send node,
1362 LocalFunctionElement function,
1363 AssignmentOperator operator,
1364 Node rhs,
1365 A arg) {
1366 return bulkHandleCompound(node, arg);
1367 }
1368
1369 @override
1370 R visitTypeVariableTypeLiteralCompound(
1371 Send node,
1372 TypeVariableElement element,
1373 AssignmentOperator operator,
1374 Node rhs,
1375 A arg) {
1376 return bulkHandleCompound(node, arg);
1377 }
1378
1379 @override
1380 R visitTypedefTypeLiteralCompound(
1381 Send node,
1382 ConstantExpression constant,
1383 AssignmentOperator operator,
1384 Node rhs,
1385 A arg) {
1386 return bulkHandleCompound(node, arg);
1387 }
1388
1389 @override
1390 R visitUnresolvedStaticGetterCompound(
1391 Send node,
1392 Element element,
1393 MethodElement setter,
1394 AssignmentOperator operator,
1395 Node rhs,
1396 A arg) {
1397 return bulkHandleCompound(node, arg);
1398 }
1399
1400 @override
1401 R visitUnresolvedTopLevelGetterCompound(
1402 Send node,
1403 Element element,
1404 MethodElement setter,
1405 AssignmentOperator operator,
1406 Node rhs,
1407 A arg) {
1408 return bulkHandleCompound(node, arg);
1409 }
1410
1411 @override
1412 R visitUnresolvedStaticSetterCompound(
1413 Send node,
1414 MethodElement getter,
1415 Element element,
1416 AssignmentOperator operator,
1417 Node rhs,
1418 A arg) {
1419 return bulkHandleCompound(node, arg);
1420 }
1421
1422 @override
1423 R visitUnresolvedTopLevelSetterCompound(
1424 Send node,
1425 MethodElement getter,
1426 Element element,
1427 AssignmentOperator operator,
1428 Node rhs,
1429 A arg) {
1430 return bulkHandleCompound(node, arg);
1431 }
1432
1433 @override
1434 R visitStaticMethodCompound(
1435 Send node,
1436 MethodElement method,
1437 AssignmentOperator operator,
1438 Node rhs,
1439 A arg) {
1440 return bulkHandleCompound(node, arg);
1441 }
1442
1443 @override
1444 R visitTopLevelMethodCompound(
1445 Send node,
1446 MethodElement method,
1447 AssignmentOperator operator,
1448 Node rhs,
1449 A arg) {
1450 return bulkHandleCompound(node, arg);
1451 }
1452
1453 @override
1454 R visitUnresolvedCompound(
1455 Send node,
1456 Element element,
1457 AssignmentOperator operator,
1458 Node rhs,
1459 A arg) {
1460 return bulkHandleCompound(node, arg);
1461 }
1462
1463 @override
1464 R visitSuperFieldFieldCompound(
1465 Send node, FieldElement readField,
1466 FieldElement writtenField,
1467 AssignmentOperator operator,
1468 Node rhs,
1469 A arg) {
1470 return bulkHandleCompound(node, arg);
1471 }
1472
1473 @override
1474 R visitSuperMethodCompound(
1475 Send node,
1476 FunctionElement method,
1477 AssignmentOperator operator,
1478 Node rhs,
1479 A arg) {
1480 return bulkHandleCompound(node, arg);
1481 }
1482
1483 @override
1484 R visitUnresolvedSuperCompound(
1485 Send node,
1486 Element element,
1487 AssignmentOperator operator,
1488 Node rhs,
1489 A arg) {
1490 return bulkHandleCompound(node, arg);
1491 }
1492
1493 @override
1494 R visitUnresolvedSuperGetterCompound(
1495 Send node, Element element,
1496 MethodElement setter,
1497 AssignmentOperator operator,
1498 Node rhs,
1499 A arg) {
1500 return bulkHandleCompound(node, arg);
1501 }
1502
1503 @override
1504 R visitUnresolvedSuperSetterCompound(
1505 Send node, MethodElement getter,
1506 Element element,
1507 AssignmentOperator operator,
1508 Node rhs,
1509 A arg) {
1510 return bulkHandleCompound(node, arg);
1511 }
1512 } 1086 }
1513 1087
1514 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by 1088 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by
1515 /// delegating to a bulk handler. 1089 /// delegating to a bulk handler.
1516 /// 1090 ///
1517 /// Use this mixin to provide a trivial implementation for all `visitXInvoke` 1091 /// Use this mixin to provide a trivial implementation for all `visitXInvoke`
1518 /// methods. 1092 /// methods.
1519 abstract class InvokeBulkMixin<R, A> 1093 abstract class InvokeBulkMixin<R, A>
1520 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 1094 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
1521 1095
(...skipping 593 matching lines...) Expand 10 before | Expand all | Expand 10 after
2115 AssignmentOperator operator, 1689 AssignmentOperator operator,
2116 Node rhs, 1690 Node rhs,
2117 A arg) { 1691 A arg) {
2118 return bulkHandleIndexSet(node, arg); 1692 return bulkHandleIndexSet(node, arg);
2119 } 1693 }
2120 1694
2121 @override 1695 @override
2122 R visitUnresolvedSuperGetterCompoundIndexSet( 1696 R visitUnresolvedSuperGetterCompoundIndexSet(
2123 SendSet node, 1697 SendSet node,
2124 Element element, 1698 Element element,
2125 MethodElement setter,
2126 Node index, 1699 Node index,
2127 AssignmentOperator operator, 1700 AssignmentOperator operator,
2128 Node rhs, 1701 Node rhs,
2129 A arg) { 1702 A arg) {
2130 return bulkHandleIndexSet(node, arg); 1703 return bulkHandleIndexSet(node, arg);
2131 } 1704 }
2132 1705
2133 @override 1706 @override
2134 R visitUnresolvedSuperSetterCompoundIndexSet( 1707 R visitUnresolvedSuperSetterCompoundIndexSet(
2135 SendSet node, 1708 SendSet node,
2136 MethodElement getter, 1709 MethodElement getter,
2137 Element element, 1710 Element element,
2138 Node index, 1711 Node index,
2139 AssignmentOperator operator, 1712 AssignmentOperator operator,
2140 Node rhs, 1713 Node rhs,
2141 A arg) { 1714 A arg) {
2142 return bulkHandleIndexSet(node, arg); 1715 return bulkHandleIndexSet(node, arg);
2143 } 1716 }
2144 1717
2145 @override 1718 @override
2146 R visitUnresolvedSuperCompoundIndexSet(
2147 SendSet node,
2148 Element element,
2149 Node index,
2150 AssignmentOperator operator,
2151 Node rhs,
2152 A arg) {
2153 return bulkHandleIndexSet(node, arg);
2154 }
2155
2156 @override
2157 R visitSuperIndexSet( 1719 R visitSuperIndexSet(
2158 SendSet node, 1720 SendSet node,
2159 FunctionElement function, 1721 FunctionElement function,
2160 Node index, 1722 Node index,
2161 Node rhs, 1723 Node rhs,
2162 A arg) { 1724 A arg) {
2163 return bulkHandleIndexSet(node, arg); 1725 return bulkHandleIndexSet(node, arg);
2164 } 1726 }
2165 1727
2166 @override 1728 @override
(...skipping 625 matching lines...) Expand 10 before | Expand all | Expand 10 after
2792 } 2354 }
2793 2355
2794 @override 2356 @override
2795 R visitConstConstructorInvoke( 2357 R visitConstConstructorInvoke(
2796 NewExpression node, 2358 NewExpression node,
2797 ConstructedConstantExpression constant, 2359 ConstructedConstantExpression constant,
2798 A arg) { 2360 A arg) {
2799 return bulkHandleNew(node, arg); 2361 return bulkHandleNew(node, arg);
2800 } 2362 }
2801 2363
2802 @override
2803 R visitGenerativeConstructorInvoke( 2364 R visitGenerativeConstructorInvoke(
2804 NewExpression node, 2365 NewExpression node,
2805 ConstructorElement constructor, 2366 ConstructorElement constructor,
2806 InterfaceType type, 2367 InterfaceType type,
2807 NodeList arguments, 2368 NodeList arguments,
2808 CallStructure callStructure, 2369 CallStructure callStructure,
2809 A arg) { 2370 A arg) {
2810 return bulkHandleNew(node, arg); 2371 return bulkHandleNew(node, arg);
2811 } 2372 }
2812 2373
2813 @override
2814 R visitRedirectingGenerativeConstructorInvoke( 2374 R visitRedirectingGenerativeConstructorInvoke(
2815 NewExpression node, 2375 NewExpression node,
2816 ConstructorElement constructor, 2376 ConstructorElement constructor,
2817 InterfaceType type, 2377 InterfaceType type,
2818 NodeList arguments, 2378 NodeList arguments,
2819 CallStructure callStructure, 2379 CallStructure callStructure,
2820 A arg) { 2380 A arg) {
2821 return bulkHandleNew(node, arg); 2381 return bulkHandleNew(node, arg);
2822 } 2382 }
2823 2383
2824 @override
2825 R visitFactoryConstructorInvoke( 2384 R visitFactoryConstructorInvoke(
2826 NewExpression node, 2385 NewExpression node,
2827 ConstructorElement constructor, 2386 ConstructorElement constructor,
2828 InterfaceType type, 2387 InterfaceType type,
2829 NodeList arguments, 2388 NodeList arguments,
2830 CallStructure callStructure, 2389 CallStructure callStructure,
2831 A arg) { 2390 A arg) {
2832 return bulkHandleNew(node, arg); 2391 return bulkHandleNew(node, arg);
2833 } 2392 }
2834 2393
2835 @override
2836 R visitRedirectingFactoryConstructorInvoke( 2394 R visitRedirectingFactoryConstructorInvoke(
2837 NewExpression node, 2395 NewExpression node,
2838 ConstructorElement constructor, 2396 ConstructorElement constructor,
2839 InterfaceType type, 2397 InterfaceType type,
2840 ConstructorElement effectiveTarget, 2398 ConstructorElement effectiveTarget,
2841 InterfaceType effectiveTargetType, 2399 InterfaceType effectiveTargetType,
2842 NodeList arguments, 2400 NodeList arguments,
2843 CallStructure callStructure, 2401 CallStructure callStructure,
2844 A arg) { 2402 A arg) {
2845 return bulkHandleNew(node, arg); 2403 return bulkHandleNew(node, arg);
(...skipping 548 matching lines...) Expand 10 before | Expand all | Expand 10 after
3394 return null; 2952 return null;
3395 } 2953 }
3396 2954
3397 @override 2955 @override
3398 R errorClassTypeLiteralSet( 2956 R errorClassTypeLiteralSet(
3399 SendSet node, 2957 SendSet node,
3400 ConstantExpression constant, 2958 ConstantExpression constant,
3401 Node rhs, 2959 Node rhs,
3402 A arg) { 2960 A arg) {
3403 apply(rhs, arg); 2961 apply(rhs, arg);
2962 return null;
2963 }
2964
2965 @override
2966 R errorDynamicTypeLiteralSet(
2967 SendSet node,
2968 ConstantExpression constant,
2969 Node rhs,
2970 A arg) {
2971 apply(rhs, arg);
2972 return null;
2973 }
2974
2975 @override
2976 R errorFinalLocalVariableCompound(
2977 Send node,
2978 LocalVariableElement variable,
2979 AssignmentOperator operator,
2980 Node rhs,
2981 A arg) {
2982 apply(rhs, arg);
2983 return null;
2984 }
2985
2986 @override
2987 R errorFinalLocalVariableSet(
2988 SendSet node,
2989 LocalVariableElement variable,
2990 Node rhs,
2991 A arg) {
2992 apply(rhs, arg);
2993 return null;
2994 }
2995
2996 @override
2997 R errorFinalParameterCompound(
2998 Send node,
2999 ParameterElement parameter,
3000 AssignmentOperator operator,
3001 Node rhs,
3002 A arg) {
3003 apply(rhs, arg);
3004 return null;
3005 }
3006
3007 @override
3008 R errorFinalParameterSet(
3009 SendSet node,
3010 ParameterElement parameter,
3011 Node rhs,
3012 A arg) {
3013 apply(rhs, arg);
3014 return null;
3015 }
3016
3017 @override
3018 R errorFinalStaticFieldCompound(
3019 Send node,
3020 FieldElement field,
3021 AssignmentOperator operator,
3022 Node rhs,
3023 A arg) {
3024 apply(rhs, arg);
3025 return null;
3026 }
3027
3028 @override
3029 R errorFinalStaticFieldSet(
3030 SendSet node,
3031 FieldElement field,
3032 Node rhs,
3033 A arg) {
3034 apply(rhs, arg);
3035 return null;
3036 }
3037
3038 @override
3039 R errorFinalSuperFieldCompound(
3040 Send node,
3041 FieldElement field,
3042 AssignmentOperator operator,
3043 Node rhs,
3044 A arg) {
3045 apply(rhs, arg);
3046 return null;
3047 }
3048
3049 @override
3050 R errorFinalSuperFieldSet(
3051 SendSet node,
3052 FieldElement field,
3053 Node rhs,
3054 A arg) {
3055 apply(rhs, arg);
3056 return null;
3057 }
3058
3059 @override
3060 R errorFinalTopLevelFieldCompound(
3061 Send node,
3062 FieldElement field,
3063 AssignmentOperator operator,
3064 Node rhs,
3065 A arg) {
3066 apply(rhs, arg);
3067 return null;
3068 }
3069
3070 @override
3071 R errorFinalTopLevelFieldSet(
3072 SendSet node,
3073 FieldElement field,
3074 Node rhs,
3075 A arg) {
3076 apply(rhs, arg);
3077 return null;
3078 }
3079
3080 @override
3081 R errorLocalFunctionCompound(
3082 Send node,
3083 LocalFunctionElement function,
3084 AssignmentOperator operator,
3085 Node rhs,
3086 A arg) {
3087 apply(rhs, arg);
3088 return null;
3089 }
3090
3091 @override
3092 R errorLocalFunctionPostfix(
3093 Send node,
3094 LocalFunctionElement function,
3095 IncDecOperator operator,
3096 A arg) {
3097 return null;
3098 }
3099
3100 @override
3101 R errorLocalFunctionPrefix(
3102 Send node,
3103 LocalFunctionElement function,
3104 IncDecOperator operator,
3105 A arg) {
3106 return null;
3107 }
3108
3109 @override
3110 R errorLocalFunctionSet(
3111 SendSet node,
3112 LocalFunctionElement function,
3113 Node rhs,
3114 A arg) {
3115 apply(rhs, arg);
3116 return null;
3117 }
3118
3119 @override
3120 R errorStaticFunctionSet(
3121 Send node,
3122 MethodElement function,
3123 Node rhs,
3124 A arg) {
3125 apply(rhs, arg);
3126 return null;
3127 }
3128
3129 @override
3130 R errorStaticGetterSet(
3131 SendSet node,
3132 FunctionElement getter,
3133 Node rhs,
3134 A arg) {
3135 apply(rhs, arg);
3136 return null;
3137 }
3138
3139 @override
3140 R errorStaticSetterGet(
3141 Send node,
3142 FunctionElement setter,
3143 A arg) {
3144 return null;
3145 }
3146
3147 @override
3148 R errorStaticSetterInvoke(
3149 Send node,
3150 FunctionElement setter,
3151 NodeList arguments,
3152 CallStructure callStructure,
3153 A arg) {
3154 apply(arguments, arg);
3155 return null;
3156 }
3157
3158 @override
3159 R errorSuperGetterSet(
3160 SendSet node,
3161 FunctionElement getter,
3162 Node rhs,
3163 A arg) {
3164 apply(rhs, arg);
3165 return null;
3166 }
3167
3168 @override
3169 R errorSuperMethodSet(
3170 Send node,
3171 MethodElement method,
3172 Node rhs,
3173 A arg) {
3174 apply(rhs, arg);
3175 return null;
3176 }
3177
3178 @override
3179 R errorSuperSetterGet(
3180 Send node,
3181 FunctionElement setter,
3182 A arg) {
3183 return null;
3184 }
3185
3186 @override
3187 R errorSuperSetterInvoke(
3188 Send node,
3189 FunctionElement setter,
3190 NodeList arguments,
3191 CallStructure callStructure,
3192 A arg) {
3193 apply(arguments, arg);
3194 return null;
3195 }
3196
3197 @override
3198 R errorTopLevelFunctionSet(
3199 Send node,
3200 MethodElement function,
3201 Node rhs,
3202 A arg) {
3203 apply(rhs, arg);
3204 return null;
3205 }
3206
3207 @override
3208 R errorTopLevelGetterSet(
3209 SendSet node,
3210 FunctionElement getter,
3211 Node rhs,
3212 A arg) {
3213 apply(rhs, arg);
3214 return null;
3215 }
3216
3217 @override
3218 R errorTopLevelSetterGet(
3219 Send node,
3220 FunctionElement setter,
3221 A arg) {
3222 return null;
3223 }
3224
3225 @override
3226 R errorTopLevelSetterInvoke(
3227 Send node,
3228 FunctionElement setter,
3229 NodeList arguments,
3230 CallStructure callStructure,
3231 A arg) {
3232 apply(arguments, arg);
3233 return null;
3234 }
3235
3236 @override
3237 R errorTypeVariableTypeLiteralSet(
3238 SendSet node,
3239 TypeVariableElement element,
3240 Node rhs,
3241 A arg) {
3242 apply(rhs, arg);
3243 return null;
3244 }
3245
3246 @override
3247 R errorTypedefTypeLiteralSet(
3248 SendSet node,
3249 ConstantExpression constant,
3250 Node rhs,
3251 A arg) {
3252 apply(rhs, arg);
3253 return null;
3254 }
3255
3256 @override
3257 R visitUnresolvedSuperIndex(
3258 Send node,
3259 Element function,
3260 Node index,
3261 A arg) {
3262 apply(index, arg);
3263 return null;
3264 }
3265
3266 @override
3267 R visitUnresolvedSuperGet(
3268 Send node,
3269 Element element,
3270 A arg) {
3271 return null;
3272 }
3273
3274 @override
3275 R visitUnresolvedSuperInvoke(
3276 Send node,
3277 Element function,
3278 NodeList arguments,
3279 Selector selector,
3280 A arg) {
3281 apply(arguments, arg);
3282 return null;
3283 }
3284
3285 @override
3286 R visitAs(
3287 Send node,
3288 Node expression,
3289 DartType type,
3290 A arg) {
3291 apply(expression, arg);
3292 return null;
3293 }
3294
3295 @override
3296 R visitAssert(
3297 Send node,
3298 Node expression,
3299 A arg) {
3300 apply(expression, arg);
3301 return null;
3302 }
3303
3304 @override
3305 R visitBinary(
3306 Send node,
3307 Node left,
3308 BinaryOperator operator,
3309 Node right,
3310 A arg) {
3311 apply(left, arg);
3312 apply(right, arg);
3313 return null;
3314 }
3315
3316 @override
3317 R errorClassTypeLiteralCompound(
3318 Send node,
3319 ConstantExpression constant,
3320 AssignmentOperator operator,
3321 Node rhs,
3322 A arg) {
3323 apply(rhs, arg);
3324 return null;
3325 }
3326
3327 @override
3328 R visitClassTypeLiteralGet(
3329 Send node,
3330 ConstantExpression constant,
3331 A arg) {
3332 return null;
3333 }
3334
3335 @override
3336 R visitClassTypeLiteralInvoke(
3337 Send node,
3338 ConstantExpression constant,
3339 NodeList arguments,
3340 CallStructure callStructure,
3341 A arg) {
3342 apply(arguments, arg);
3343 return null;
3344 }
3345
3346 @override
3347 R errorClassTypeLiteralPostfix(
3348 Send node,
3349 ConstantExpression constant,
3350 IncDecOperator operator,
3351 A arg) {
3352 return null;
3353 }
3354
3355 @override
3356 R errorClassTypeLiteralPrefix(
3357 Send node,
3358 ConstantExpression constant,
3359 IncDecOperator operator,
3360 A arg) {
3361 return null;
3362 }
3363
3364 @override
3365 R visitCompoundIndexSet(
3366 SendSet node,
3367 Node receiver,
3368 Node index,
3369 AssignmentOperator operator,
3370 Node rhs,
3371 A arg) {
3372 apply(receiver, arg);
3373 apply(index, arg);
3374 apply(rhs, arg);
3375 return null;
3376 }
3377
3378 @override
3379 R visitConstantGet(
3380 Send node,
3381 ConstantExpression constant,
3382 A arg) {
3383 return null;
3384 }
3385
3386 @override
3387 R visitConstantInvoke(
3388 Send node,
3389 ConstantExpression constant,
3390 NodeList arguments,
3391 CallStructure callStructure,
3392 A arg) {
3393 apply(arguments, arg);
3394 return null;
3395 }
3396
3397 @override
3398 R visitDynamicPropertyCompound(
3399 Send node,
3400 Node receiver,
3401 AssignmentOperator operator,
3402 Node rhs,
3403 Selector getterSelector,
3404 Selector setterSelector,
3405 A arg) {
3406 apply(receiver, arg);
3407 apply(rhs, arg);
3408 return null;
3409 }
3410
3411 @override
3412 R visitDynamicPropertyGet(
3413 Send node,
3414 Node receiver,
3415 Selector selector,
3416 A arg) {
3417 apply(receiver, arg);
3418 return null;
3419 }
3420
3421 @override
3422 R visitDynamicPropertyInvoke(
3423 Send node,
3424 Node receiver,
3425 NodeList arguments,
3426 Selector selector,
3427 A arg) {
3428 apply(receiver, arg);
3429 apply(arguments, arg);
3430 return null;
3431 }
3432
3433 @override
3434 R visitDynamicPropertyPostfix(
3435 Send node,
3436 Node receiver,
3437 IncDecOperator operator,
3438 Selector getterSelector,
3439 Selector setterSelector,
3440 A arg) {
3441 apply(receiver, arg);
3442 return null;
3443 }
3444
3445 @override
3446 R visitDynamicPropertyPrefix(
3447 Send node,
3448 Node receiver,
3449 IncDecOperator operator,
3450 Selector getterSelector,
3451 Selector setterSelector,
3452 A arg) {
3453 apply(receiver, arg);
3454 return null;
3455 }
3456
3457 @override
3458 R visitDynamicPropertySet(
3459 SendSet node,
3460 Node receiver,
3461 Selector selector,
3462 Node rhs,
3463 A arg) {
3464 apply(rhs, arg);
3465 return null;
3466 }
3467
3468 @override
3469 R errorDynamicTypeLiteralCompound(
3470 Send node,
3471 ConstantExpression constant,
3472 AssignmentOperator operator,
3473 Node rhs,
3474 A arg) {
3475 apply(rhs, arg);
3476 return null;
3477 }
3478
3479 @override
3480 R visitDynamicTypeLiteralGet(
3481 Send node,
3482 ConstantExpression constant,
3483 A arg) {
3484 return null;
3485 }
3486
3487 @override
3488 R visitDynamicTypeLiteralInvoke(
3489 Send node,
3490 ConstantExpression constant,
3491 NodeList arguments,
3492 CallStructure callStructure,
3493 A arg) {
3494 apply(arguments, arg);
3495 return null;
3496 }
3497
3498 @override
3499 R errorDynamicTypeLiteralPostfix(
3500 Send node,
3501 ConstantExpression constant,
3502 IncDecOperator operator,
3503 A arg) {
3504 return null;
3505 }
3506
3507 @override
3508 R errorDynamicTypeLiteralPrefix(
3509 Send node,
3510 ConstantExpression constant,
3511 IncDecOperator operator,
3512 A arg) {
3513 return null;
3514 }
3515
3516 @override
3517 R visitEquals(
3518 Send node,
3519 Node left,
3520 Node right,
3521 A arg) {
3522 apply(left, arg);
3523 apply(right, arg);
3524 return null;
3525 }
3526
3527 @override
3528 R visitExpressionInvoke(
3529 Send node,
3530 Node expression,
3531 NodeList arguments,
3532 Selector selector,
3533 A arg) {
3534 apply(expression, arg);
3535 apply(arguments, arg);
3536 return null;
3537 }
3538
3539 @override
3540 R visitIndex(
3541 Send node,
3542 Node receiver,
3543 Node index,
3544 A arg) {
3545 apply(receiver, arg);
3546 apply(index, arg);
3547 return null;
3548 }
3549
3550 @override
3551 R visitIndexSet(
3552 SendSet node,
3553 Node receiver,
3554 Node index,
3555 Node rhs,
3556 A arg) {
3557 apply(receiver, arg);
3558 apply(index, arg);
3559 apply(rhs, arg);
3560 return null;
3561 }
3562
3563 @override
3564 R visitIs(
3565 Send node,
3566 Node expression,
3567 DartType type,
3568 A arg) {
3569 apply(expression, arg);
3570 return null;
3571 }
3572
3573 @override
3574 R visitIsNot(
3575 Send node,
3576 Node expression,
3577 DartType type,
3578 A arg) {
3579 apply(expression, arg);
3580 return null;
3581 }
3582
3583 @override
3584 R visitLocalFunctionGet(
3585 Send node,
3586 LocalFunctionElement function,
3587 A arg) {
3588 return null;
3589 }
3590
3591 @override
3592 R visitLocalFunctionInvoke(
3593 Send node,
3594 LocalFunctionElement function,
3595 NodeList arguments,
3596 CallStructure callStructure,
3597 A arg) {
3598 apply(arguments, arg);
3599 return null;
3600 }
3601
3602 @override
3603 R visitLocalVariableCompound(
3604 Send node,
3605 LocalVariableElement variable,
3606 AssignmentOperator operator,
3607 Node rhs,
3608 A arg) {
3609 apply(rhs, arg);
3610 return null;
3611 }
3612
3613 @override
3614 R visitLocalVariableGet(
3615 Send node,
3616 LocalVariableElement variable,
3617 A arg) {
3618 return null;
3619 }
3620
3621 @override
3622 R visitLocalVariableInvoke(
3623 Send node,
3624 LocalVariableElement variable,
3625 NodeList arguments,
3626 CallStructure callStructure,
3627 A arg) {
3628 apply(arguments, arg);
3629 return null;
3630 }
3631
3632 @override
3633 R visitLocalVariablePostfix(
3634 Send node,
3635 LocalVariableElement variable,
3636 IncDecOperator operator,
3637 A arg) {
3638 return null;
3639 }
3640
3641 @override
3642 R visitLocalVariablePrefix(
3643 Send node,
3644 LocalVariableElement variable,
3645 IncDecOperator operator,
3646 A arg) {
3647 return null;
3648 }
3649
3650 @override
3651 R visitLocalVariableSet(
3652 SendSet node,
3653 LocalVariableElement variable,
3654 Node rhs,
3655 A arg) {
3656 apply(rhs, arg);
3404 return null; 3657 return null;
3405 } 3658 }
3406 3659
3407 @override 3660 @override
3408 R errorDynamicTypeLiteralSet( 3661 R visitLogicalAnd(
3409 SendSet node, 3662 Send node,
3410 ConstantExpression constant, 3663 Node left,
3411 Node rhs, 3664 Node right,
3412 A arg) { 3665 A arg) {
3413 apply(rhs, arg); 3666 apply(left, arg);
3667 apply(right, arg);
3414 return null; 3668 return null;
3415 } 3669 }
3416 3670
3417 @override 3671 @override
3418 R visitFinalLocalVariableCompound( 3672 R visitLogicalOr(
3419 Send node, 3673 Send node,
3420 LocalVariableElement variable, 3674 Node left,
3421 AssignmentOperator operator, 3675 Node right,
3422 Node rhs,
3423 A arg) { 3676 A arg) {
3424 apply(rhs, arg); 3677 apply(left, arg);
3678 apply(right, arg);
3425 return null; 3679 return null;
3426 } 3680 }
3427 3681
3428 @override 3682 @override
3429 R errorFinalLocalVariableSet( 3683 R visitNot(
3430 SendSet node, 3684 Send node,
3431 LocalVariableElement variable, 3685 Node expression,
3432 Node rhs,
3433 A arg) { 3686 A arg) {
3434 apply(rhs, arg); 3687 apply(expression, arg);
3435 return null; 3688 return null;
3436 } 3689 }
3437 3690
3438 @override 3691 @override
3439 R visitFinalParameterCompound( 3692 R visitNotEquals(
3693 Send node,
3694 Node left,
3695 Node right,
3696 A arg) {
3697 apply(left, arg);
3698 apply(right, arg);
3699 return null;
3700 }
3701
3702 @override
3703 R visitParameterCompound(
3440 Send node, 3704 Send node,
3441 ParameterElement parameter, 3705 ParameterElement parameter,
3442 AssignmentOperator operator, 3706 AssignmentOperator operator,
3443 Node rhs, 3707 Node rhs,
3444 A arg) { 3708 A arg) {
3445 apply(rhs, arg); 3709 apply(rhs, arg);
3446 return null;
3447 }
3448
3449 @override
3450 R errorFinalParameterSet(
3451 SendSet node,
3452 ParameterElement parameter,
3453 Node rhs,
3454 A arg) {
3455 apply(rhs, arg);
3456 return null; 3710 return null;
3457 } 3711 }
3458 3712
3459 @override 3713 @override
3460 R visitFinalStaticFieldCompound( 3714 R visitParameterGet(
3461 Send node, 3715 Send node,
3462 FieldElement field, 3716 ParameterElement parameter,
3463 AssignmentOperator operator,
3464 Node rhs,
3465 A arg) { 3717 A arg) {
3466 apply(rhs, arg);
3467 return null; 3718 return null;
3468 } 3719 }
3469 3720
3470 @override 3721 @override
3471 R errorFinalStaticFieldSet( 3722 R visitParameterInvoke(
3472 SendSet node, 3723 Send node,
3473 FieldElement field, 3724 ParameterElement parameter,
3474 Node rhs, 3725 NodeList arguments,
3726 CallStructure callStructure,
3475 A arg) { 3727 A arg) {
3476 apply(rhs, arg); 3728 apply(arguments, arg);
3477 return null; 3729 return null;
3478 } 3730 }
3479 3731
3480 @override 3732 @override
3481 R errorFinalSuperFieldSet( 3733 R visitParameterPostfix(
3482 SendSet node, 3734 Send node,
3483 FieldElement field, 3735 ParameterElement parameter,
3484 Node rhs, 3736 IncDecOperator operator,
3485 A arg) { 3737 A arg) {
3486 apply(rhs, arg);
3487 return null; 3738 return null;
3488 } 3739 }
3489 3740
3490 @override 3741 @override
3491 R visitFinalTopLevelFieldCompound( 3742 R visitParameterPrefix(
3492 Send node, 3743 Send node,
3493 FieldElement field, 3744 ParameterElement parameter,
3494 AssignmentOperator operator, 3745 IncDecOperator operator,
3495 Node rhs,
3496 A arg) { 3746 A arg) {
3497 apply(rhs, arg);
3498 return null; 3747 return null;
3499 } 3748 }
3500 3749
3501 @override 3750 @override
3502 R errorFinalTopLevelFieldSet( 3751 R visitParameterSet(
3503 SendSet node, 3752 SendSet node,
3504 FieldElement field, 3753 ParameterElement parameter,
3505 Node rhs, 3754 Node rhs,
3506 A arg) { 3755 A arg) {
3507 apply(rhs, arg); 3756 apply(rhs, arg);
3508 return null; 3757 return null;
3509 } 3758 }
3510 3759
3511 @override 3760 @override
3512 R visitLocalFunctionCompound( 3761 R visitStaticFieldCompound(
3513 Send node, 3762 Send node,
3514 LocalFunctionElement function, 3763 FieldElement field,
3515 AssignmentOperator operator, 3764 AssignmentOperator operator,
3516 Node rhs, 3765 Node rhs,
3517 A arg) { 3766 A arg) {
3518 apply(rhs, arg); 3767 apply(rhs, arg);
3519 return null; 3768 return null;
3520 } 3769 }
3521 3770
3522 @override 3771 @override
3523 R visitLocalFunctionPostfix( 3772 R visitStaticFieldGet(
3524 Send node, 3773 Send node,
3525 LocalFunctionElement function, 3774 FieldElement field,
3775 A arg) {
3776 return null;
3777 }
3778
3779 @override
3780 R visitStaticFieldInvoke(
3781 Send node,
3782 FieldElement field,
3783 NodeList arguments,
3784 CallStructure callStructure,
3785 A arg) {
3786 apply(arguments, arg);
3787 return null;
3788 }
3789
3790 @override
3791 R visitStaticFieldPostfix(
3792 Send node,
3793 FieldElement field,
3526 IncDecOperator operator, 3794 IncDecOperator operator,
3527 A arg) { 3795 A arg) {
3528 return null; 3796 return null;
3529 } 3797 }
3530 3798
3531 @override 3799 @override
3532 R visitLocalFunctionPrefix( 3800 R visitStaticFieldPrefix(
3533 Send node, 3801 Send node,
3534 LocalFunctionElement function, 3802 FieldElement field,
3535 IncDecOperator operator, 3803 IncDecOperator operator,
3536 A arg) { 3804 A arg) {
3537 return null; 3805 return null;
3538 } 3806 }
3539 3807
3540 @override 3808 @override
3541 R errorLocalFunctionSet( 3809 R visitStaticFieldSet(
3542 SendSet node, 3810 SendSet node,
3543 LocalFunctionElement function, 3811 FieldElement field,
3544 Node rhs, 3812 Node rhs,
3545 A arg) { 3813 A arg) {
3546 apply(rhs, arg); 3814 apply(rhs, arg);
3547 return null;
3548 }
3549
3550 @override
3551 R errorStaticFunctionSet(
3552 Send node,
3553 MethodElement function,
3554 Node rhs,
3555 A arg) {
3556 apply(rhs, arg);
3557 return null;
3558 }
3559
3560 @override
3561 R errorStaticGetterSet(
3562 SendSet node,
3563 FunctionElement getter,
3564 Node rhs,
3565 A arg) {
3566 apply(rhs, arg);
3567 return null; 3815 return null;
3568 } 3816 }
3569 3817
3570 @override 3818 @override
3571 R errorStaticSetterGet( 3819 R visitStaticFunctionGet(
3572 Send node, 3820 Send node,
3573 FunctionElement setter, 3821 MethodElement function,
3574 A arg) { 3822 A arg) {
3575 return null; 3823 return null;
3576 } 3824 }
3577 3825
3578 @override 3826 @override
3579 R errorStaticSetterInvoke( 3827 R visitStaticFunctionInvoke(
3580 Send node, 3828 Send node,
3581 FunctionElement setter, 3829 MethodElement function,
3582 NodeList arguments, 3830 NodeList arguments,
3583 CallStructure callStructure, 3831 CallStructure callStructure,
3584 A arg) { 3832 A arg) {
3585 apply(arguments, arg); 3833 apply(arguments, arg);
3586 return null; 3834 return null;
3587 } 3835 }
3588 3836
3589 @override 3837 @override
3590 R errorSuperGetterSet( 3838 R visitStaticFunctionIncompatibleInvoke(
3591 SendSet node, 3839 Send node,
3592 FunctionElement getter, 3840 MethodElement function,
3593 Node rhs, 3841 NodeList arguments,
3842 CallStructure callStructure,
3594 A arg) { 3843 A arg) {
3595 apply(rhs, arg); 3844 apply(arguments, arg);
3596 return null; 3845 return null;
3597 } 3846 }
3598 3847
3599 @override 3848 @override
3600 R errorSuperMethodSet( 3849 R visitStaticGetterGet(
3601 Send node, 3850 Send node,
3602 MethodElement method, 3851 FunctionElement getter,
3603 Node rhs,
3604 A arg) {
3605 apply(rhs, arg);
3606 return null;
3607 }
3608
3609 @override
3610 R errorSuperSetterGet(
3611 Send node,
3612 FunctionElement setter,
3613 A arg) { 3852 A arg) {
3614 return null; 3853 return null;
3615 } 3854 }
3616 3855
3617 @override 3856 @override
3618 R errorSuperSetterInvoke( 3857 R visitStaticGetterInvoke(
3619 Send node, 3858 Send node,
3620 FunctionElement setter, 3859 FunctionElement getter,
3621 NodeList arguments, 3860 NodeList arguments,
3622 CallStructure callStructure, 3861 CallStructure callStructure,
3623 A arg) { 3862 A arg) {
3624 apply(arguments, arg); 3863 apply(arguments, arg);
3625 return null; 3864 return null;
3626 } 3865 }
3627 3866
3628 @override 3867 @override
3629 R errorTopLevelFunctionSet( 3868 R visitStaticGetterSetterCompound(
3630 Send node, 3869 Send node,
3631 MethodElement function, 3870 FunctionElement getter,
3871 FunctionElement setter,
3872 AssignmentOperator operator,
3632 Node rhs, 3873 Node rhs,
3633 A arg) { 3874 A arg) {
3634 apply(rhs, arg); 3875 apply(rhs, arg);
3635 return null; 3876 return null;
3636 } 3877 }
3637 3878
3638 @override 3879 @override
3639 R errorTopLevelGetterSet( 3880 R visitStaticGetterSetterPostfix(
3640 SendSet node, 3881 Send node,
3641 FunctionElement getter, 3882 FunctionElement getter,
3642 Node rhs,
3643 A arg) {
3644 apply(rhs, arg);
3645 return null;
3646 }
3647
3648 @override
3649 R errorTopLevelSetterGet(
3650 Send node,
3651 FunctionElement setter, 3883 FunctionElement setter,
3884 IncDecOperator operator,
3652 A arg) { 3885 A arg) {
3653 return null; 3886 return null;
3654 } 3887 }
3655 3888
3656 @override 3889 @override
3657 R errorTopLevelSetterInvoke( 3890 R visitStaticGetterSetterPrefix(
3658 Send node, 3891 Send node,
3892 FunctionElement getter,
3659 FunctionElement setter, 3893 FunctionElement setter,
3660 NodeList arguments, 3894 IncDecOperator operator,
3661 CallStructure callStructure,
3662 A arg) {
3663 apply(arguments, arg);
3664 return null;
3665 }
3666
3667 @override
3668 R errorTypeVariableTypeLiteralSet(
3669 SendSet node,
3670 TypeVariableElement element,
3671 Node rhs,
3672 A arg) {
3673 apply(rhs, arg);
3674 return null;
3675 }
3676
3677 @override
3678 R errorTypedefTypeLiteralSet(
3679 SendSet node,
3680 ConstantExpression constant,
3681 Node rhs,
3682 A arg) {
3683 apply(rhs, arg);
3684 return null;
3685 }
3686
3687 @override
3688 R visitUnresolvedSuperIndex(
3689 Send node,
3690 Element function,
3691 Node index,
3692 A arg) {
3693 apply(index, arg);
3694 return null;
3695 }
3696
3697 @override
3698 R visitUnresolvedSuperGet(
3699 Send node,
3700 Element element,
3701 A arg) { 3895 A arg) {
3702 return null; 3896 return null;
3703 } 3897 }
3704 3898
3705 @override 3899 @override
3706 R visitUnresolvedSuperInvoke( 3900 R visitStaticMethodSetterCompound(
3707 Send node, 3901 Send node,
3708 Element function, 3902 FunctionElement method,
3709 NodeList arguments, 3903 FunctionElement setter,
3710 Selector selector,
3711 A arg) {
3712 apply(arguments, arg);
3713 return null;
3714 }
3715
3716 @override
3717 R visitAs(
3718 Send node,
3719 Node expression,
3720 DartType type,
3721 A arg) {
3722 apply(expression, arg);
3723 return null;
3724 }
3725
3726 @override
3727 R visitAssert(
3728 Send node,
3729 Node expression,
3730 A arg) {
3731 apply(expression, arg);
3732 return null;
3733 }
3734
3735 @override
3736 R visitBinary(
3737 Send node,
3738 Node left,
3739 BinaryOperator operator,
3740 Node right,
3741 A arg) {
3742 apply(left, arg);
3743 apply(right, arg);
3744 return null;
3745 }
3746
3747 @override
3748 R visitClassTypeLiteralCompound(
3749 Send node,
3750 ConstantExpression constant,
3751 AssignmentOperator operator, 3904 AssignmentOperator operator,
3752 Node rhs, 3905 Node rhs,
3753 A arg) { 3906 A arg) {
3754 apply(rhs, arg); 3907 apply(rhs, arg);
3755 return null; 3908 return null;
3756 } 3909 }
3757 3910
3758 @override 3911 @override
3759 R visitClassTypeLiteralGet( 3912 R visitStaticMethodSetterPostfix(
3760 Send node, 3913 Send node,
3761 ConstantExpression constant, 3914 FunctionElement getter,
3915 FunctionElement setter,
3916 IncDecOperator operator,
3762 A arg) { 3917 A arg) {
3763 return null; 3918 return null;
3764 } 3919 }
3765 3920
3766 @override 3921 @override
3767 R visitClassTypeLiteralInvoke( 3922 R visitStaticMethodSetterPrefix(
3768 Send node, 3923 Send node,
3769 ConstantExpression constant, 3924 FunctionElement getter,
3925 FunctionElement setter,
3926 IncDecOperator operator,
3927 A arg) {
3928 return null;
3929 }
3930
3931 @override
3932 R visitStaticSetterSet(
3933 SendSet node,
3934 FunctionElement setter,
3935 Node rhs,
3936 A arg) {
3937 apply(rhs, arg);
3938 return null;
3939 }
3940
3941 @override
3942 R visitSuperBinary(
3943 Send node,
3944 FunctionElement function,
3945 BinaryOperator operator,
3946 Node argument,
3947 A arg) {
3948 apply(argument, arg);
3949 return null;
3950 }
3951
3952 @override
3953 R visitSuperCompoundIndexSet(
3954 SendSet node,
3955 FunctionElement getter,
3956 FunctionElement setter,
3957 Node index,
3958 AssignmentOperator operator,
3959 Node rhs,
3960 A arg) {
3961 apply(rhs, arg);
3962 return null;
3963 }
3964
3965 @override
3966 R visitSuperEquals(
3967 Send node,
3968 FunctionElement function,
3969 Node argument,
3970 A arg) {
3971 apply(argument, arg);
3972 return null;
3973 }
3974
3975 @override
3976 R visitSuperFieldCompound(
3977 Send node,
3978 FieldElement field,
3979 AssignmentOperator operator,
3980 Node rhs,
3981 A arg) {
3982 apply(rhs, arg);
3983 return null;
3984 }
3985
3986 @override
3987 R visitSuperFieldFieldPostfix(
3988 Send node,
3989 FieldElement readField,
3990 FieldElement writtenField,
3991 IncDecOperator operator,
3992 A arg) {
3993 return null;
3994 }
3995
3996 @override
3997 R visitSuperFieldFieldPrefix(
3998 Send node,
3999 FieldElement readField,
4000 FieldElement writtenField,
4001 IncDecOperator operator,
4002 A arg) {
4003 return null;
4004 }
4005
4006 @override
4007 R visitSuperFieldGet(
4008 Send node,
4009 FieldElement field,
4010 A arg) {
4011 return null;
4012 }
4013
4014 @override
4015 R visitSuperFieldInvoke(
4016 Send node,
4017 FieldElement field,
3770 NodeList arguments, 4018 NodeList arguments,
3771 CallStructure callStructure, 4019 CallStructure callStructure,
3772 A arg) { 4020 A arg) {
3773 apply(arguments, arg); 4021 apply(arguments, arg);
3774 return null; 4022 return null;
3775 } 4023 }
3776 4024
3777 @override 4025 @override
3778 R visitClassTypeLiteralPostfix( 4026 R visitSuperFieldPostfix(
3779 Send node, 4027 Send node,
3780 ConstantExpression constant, 4028 FieldElement field,
3781 IncDecOperator operator, 4029 IncDecOperator operator,
3782 A arg) { 4030 A arg) {
3783 return null; 4031 return null;
3784 } 4032 }
3785 4033
3786 @override 4034 @override
3787 R visitClassTypeLiteralPrefix( 4035 R visitSuperFieldPrefix(
3788 Send node, 4036 Send node,
3789 ConstantExpression constant, 4037 FieldElement field,
3790 IncDecOperator operator, 4038 IncDecOperator operator,
3791 A arg) { 4039 A arg) {
3792 return null; 4040 return null;
3793 } 4041 }
3794 4042
3795 @override 4043 @override
3796 R visitCompoundIndexSet( 4044 R visitSuperFieldSet(
3797 SendSet node, 4045 SendSet node,
3798 Node receiver, 4046 FieldElement field,
3799 Node index,
3800 AssignmentOperator operator,
3801 Node rhs,
3802 A arg) {
3803 apply(receiver, arg);
3804 apply(index, arg);
3805 apply(rhs, arg);
3806 return null;
3807 }
3808
3809 @override
3810 R visitConstantGet(
3811 Send node,
3812 ConstantExpression constant,
3813 A arg) {
3814 return null;
3815 }
3816
3817 @override
3818 R visitConstantInvoke(
3819 Send node,
3820 ConstantExpression constant,
3821 NodeList arguments,
3822 CallStructure callStructure,
3823 A arg) {
3824 apply(arguments, arg);
3825 return null;
3826 }
3827
3828 @override
3829 R visitDynamicPropertyCompound(
3830 Send node,
3831 Node receiver,
3832 AssignmentOperator operator,
3833 Node rhs,
3834 Selector getterSelector,
3835 Selector setterSelector,
3836 A arg) {
3837 apply(receiver, arg);
3838 apply(rhs, arg);
3839 return null;
3840 }
3841
3842 @override
3843 R visitDynamicPropertyGet(
3844 Send node,
3845 Node receiver,
3846 Selector selector,
3847 A arg) {
3848 apply(receiver, arg);
3849 return null;
3850 }
3851
3852 @override
3853 R visitDynamicPropertyInvoke(
3854 Send node,
3855 Node receiver,
3856 NodeList arguments,
3857 Selector selector,
3858 A arg) {
3859 apply(receiver, arg);
3860 apply(arguments, arg);
3861 return null;
3862 }
3863
3864 @override
3865 R visitDynamicPropertyPostfix(
3866 Send node,
3867 Node receiver,
3868 IncDecOperator operator,
3869 Selector getterSelector,
3870 Selector setterSelector,
3871 A arg) {
3872 apply(receiver, arg);
3873 return null;
3874 }
3875
3876 @override
3877 R visitDynamicPropertyPrefix(
3878 Send node,
3879 Node receiver,
3880 IncDecOperator operator,
3881 Selector getterSelector,
3882 Selector setterSelector,
3883 A arg) {
3884 apply(receiver, arg);
3885 return null;
3886 }
3887
3888 @override
3889 R visitDynamicPropertySet(
3890 SendSet node,
3891 Node receiver,
3892 Selector selector,
3893 Node rhs, 4047 Node rhs,
3894 A arg) { 4048 A arg) {
3895 apply(rhs, arg); 4049 apply(rhs, arg);
3896 return null; 4050 return null;
3897 } 4051 }
3898 4052
3899 @override 4053 @override
3900 R visitDynamicTypeLiteralCompound( 4054 R visitSuperFieldSetterCompound(
3901 Send node, 4055 Send node,
3902 ConstantExpression constant, 4056 FieldElement field,
4057 FunctionElement setter,
3903 AssignmentOperator operator, 4058 AssignmentOperator operator,
3904 Node rhs, 4059 Node rhs,
3905 A arg) { 4060 A arg) {
3906 apply(rhs, arg); 4061 apply(rhs, arg);
3907 return null; 4062 return null;
3908 } 4063 }
3909 4064
3910 @override 4065 @override
3911 R visitDynamicTypeLiteralGet( 4066 R visitSuperFieldSetterPostfix(
3912 Send node, 4067 Send node,
3913 ConstantExpression constant, 4068 FieldElement field,
4069 FunctionElement setter,
4070 IncDecOperator operator,
3914 A arg) { 4071 A arg) {
3915 return null; 4072 return null;
3916 } 4073 }
3917 4074
3918 @override 4075 @override
3919 R visitDynamicTypeLiteralInvoke( 4076 R visitSuperFieldSetterPrefix(
3920 Send node, 4077 Send node,
3921 ConstantExpression constant, 4078 FieldElement field,
4079 FunctionElement setter,
4080 IncDecOperator operator,
4081 A arg) {
4082 return null;
4083 }
4084
4085 @override
4086 R visitSuperGetterFieldCompound(
4087 Send node,
4088 FunctionElement getter,
4089 FieldElement field,
4090 AssignmentOperator operator,
4091 Node rhs,
4092 A arg) {
4093 apply(rhs, arg);
4094 return null;
4095 }
4096
4097 @override
4098 R visitSuperGetterFieldPostfix(
4099 Send node,
4100 FunctionElement getter,
4101 FieldElement field,
4102 IncDecOperator operator,
4103 A arg) {
4104 return null;
4105 }
4106
4107 @override
4108 R visitSuperGetterFieldPrefix(
4109 Send node,
4110 FunctionElement getter,
4111 FieldElement field,
4112 IncDecOperator operator,
4113 A arg) {
4114 return null;
4115 }
4116
4117 @override
4118 R visitSuperGetterGet(
4119 Send node,
4120 FunctionElement getter,
4121 A arg) {
4122 return null;
4123 }
4124
4125 @override
4126 R visitSuperGetterInvoke(
4127 Send node,
4128 FunctionElement getter,
3922 NodeList arguments, 4129 NodeList arguments,
3923 CallStructure callStructure, 4130 CallStructure callStructure,
3924 A arg) { 4131 A arg) {
3925 apply(arguments, arg); 4132 apply(arguments, arg);
3926 return null; 4133 return null;
3927 } 4134 }
3928 4135
3929 @override 4136 @override
3930 R visitDynamicTypeLiteralPostfix( 4137 R visitSuperGetterSetterCompound(
3931 Send node, 4138 Send node,
3932 ConstantExpression constant, 4139 FunctionElement getter,
4140 FunctionElement setter,
4141 AssignmentOperator operator,
4142 Node rhs,
4143 A arg) {
4144 apply(rhs, arg);
4145 return null;
4146 }
4147
4148 @override
4149 R visitSuperGetterSetterPostfix(
4150 Send node,
4151 FunctionElement getter,
4152 FunctionElement setter,
3933 IncDecOperator operator, 4153 IncDecOperator operator,
3934 A arg) { 4154 A arg) {
3935 return null; 4155 return null;
3936 } 4156 }
3937 4157
3938 @override 4158 @override
3939 R visitDynamicTypeLiteralPrefix( 4159 R visitSuperGetterSetterPrefix(
3940 Send node, 4160 Send node,
3941 ConstantExpression constant, 4161 FunctionElement getter,
4162 FunctionElement setter,
3942 IncDecOperator operator, 4163 IncDecOperator operator,
3943 A arg) { 4164 A arg) {
3944 return null; 4165 return null;
3945 } 4166 }
3946 4167
3947 @override 4168 @override
3948 R visitEquals( 4169 R visitSuperIndex(
3949 Send node, 4170 Send node,
3950 Node left, 4171 FunctionElement function,
3951 Node right,
3952 A arg) {
3953 apply(left, arg);
3954 apply(right, arg);
3955 return null;
3956 }
3957
3958 @override
3959 R visitExpressionInvoke(
3960 Send node,
3961 Node expression,
3962 NodeList arguments,
3963 Selector selector,
3964 A arg) {
3965 apply(expression, arg);
3966 apply(arguments, arg);
3967 return null;
3968 }
3969
3970 @override
3971 R visitIndex(
3972 Send node,
3973 Node receiver,
3974 Node index, 4172 Node index,
3975 A arg) { 4173 A arg) {
3976 apply(receiver, arg);
3977 apply(index, arg); 4174 apply(index, arg);
3978 return null; 4175 return null;
3979 } 4176 }
3980 4177
3981 @override 4178 @override
3982 R visitIndexSet( 4179 R visitSuperIndexSet(
3983 SendSet node, 4180 SendSet node,
3984 Node receiver, 4181 FunctionElement function,
3985 Node index, 4182 Node index,
3986 Node rhs, 4183 Node rhs,
3987 A arg) { 4184 A arg) {
3988 apply(receiver, arg);
3989 apply(index, arg); 4185 apply(index, arg);
3990 apply(rhs, arg); 4186 apply(rhs, arg);
3991 return null; 4187 return null;
3992 } 4188 }
3993 4189
3994 @override 4190 @override
3995 R visitIs( 4191 R visitSuperMethodGet(
3996 Send node, 4192 Send node,
3997 Node expression, 4193 MethodElement method,
3998 DartType type,
3999 A arg) {
4000 apply(expression, arg);
4001 return null;
4002 }
4003
4004 @override
4005 R visitIsNot(
4006 Send node,
4007 Node expression,
4008 DartType type,
4009 A arg) {
4010 apply(expression, arg);
4011 return null;
4012 }
4013
4014 @override
4015 R visitLocalFunctionGet(
4016 Send node,
4017 LocalFunctionElement function,
4018 A arg) { 4194 A arg) {
4019 return null; 4195 return null;
4020 } 4196 }
4021 4197
4022 @override 4198 @override
4023 R visitLocalFunctionInvoke( 4199 R visitSuperMethodInvoke(
4024 Send node, 4200 Send node,
4025 LocalFunctionElement function, 4201 MethodElement method,
4026 NodeList arguments, 4202 NodeList arguments,
4027 CallStructure callStructure, 4203 CallStructure callStructure,
4028 A arg) { 4204 A arg) {
4205 apply(arguments, arg);
4206 return null;
4207 }
4208
4209 @override
4210 R visitSuperMethodIncompatibleInvoke(
4211 Send node,
4212 MethodElement method,
4213 NodeList arguments,
4214 CallStructure callStructure,
4215 A arg) {
4029 apply(arguments, arg); 4216 apply(arguments, arg);
4030 return null; 4217 return null;
4031 } 4218 }
4032 4219
4033 @override 4220 @override
4034 R visitLocalVariableCompound( 4221 R visitSuperMethodSetterCompound(
4035 Send node, 4222 Send node,
4036 LocalVariableElement variable, 4223 FunctionElement method,
4224 FunctionElement setter,
4037 AssignmentOperator operator, 4225 AssignmentOperator operator,
4038 Node rhs, 4226 Node rhs,
4039 A arg) { 4227 A arg) {
4040 apply(rhs, arg); 4228 apply(rhs, arg);
4041 return null; 4229 return null;
4042 } 4230 }
4043 4231
4044 @override 4232 @override
4045 R visitLocalVariableGet( 4233 R visitSuperMethodSetterPostfix(
4046 Send node, 4234 Send node,
4047 LocalVariableElement variable, 4235 FunctionElement method,
4048 A arg) { 4236 FunctionElement setter,
4049 return null;
4050 }
4051
4052 @override
4053 R visitLocalVariableInvoke(
4054 Send node,
4055 LocalVariableElement variable,
4056 NodeList arguments,
4057 CallStructure callStructure,
4058 A arg) {
4059 apply(arguments, arg);
4060 return null;
4061 }
4062
4063 @override
4064 R visitLocalVariablePostfix(
4065 Send node,
4066 LocalVariableElement variable,
4067 IncDecOperator operator, 4237 IncDecOperator operator,
4068 A arg) { 4238 A arg) {
4069 return null; 4239 return null;
4070 } 4240 }
4071 4241
4072 @override 4242 @override
4073 R visitLocalVariablePrefix( 4243 R visitSuperMethodSetterPrefix(
4074 Send node, 4244 Send node,
4075 LocalVariableElement variable, 4245 FunctionElement method,
4246 FunctionElement setter,
4076 IncDecOperator operator, 4247 IncDecOperator operator,
4077 A arg) { 4248 A arg) {
4078 return null; 4249 return null;
4079 } 4250 }
4080 4251
4081 @override 4252 @override
4082 R visitLocalVariableSet( 4253 R visitSuperNotEquals(
4254 Send node,
4255 FunctionElement function,
4256 Node argument,
4257 A arg) {
4258 apply(argument, arg);
4259 return null;
4260 }
4261
4262 @override
4263 R visitSuperSetterSet(
4083 SendSet node, 4264 SendSet node,
4084 LocalVariableElement variable, 4265 FunctionElement setter,
4085 Node rhs, 4266 Node rhs,
4086 A arg) { 4267 A arg) {
4087 apply(rhs, arg); 4268 apply(rhs, arg);
4088 return null; 4269 return null;
4089 } 4270 }
4090 4271
4091 @override 4272 @override
4092 R visitLogicalAnd( 4273 R visitSuperUnary(
4093 Send node, 4274 Send node,
4094 Node left, 4275 UnaryOperator operator,
4095 Node right, 4276 FunctionElement function,
4096 A arg) {
4097 apply(left, arg);
4098 apply(right, arg);
4099 return null;
4100 }
4101
4102 @override
4103 R visitLogicalOr(
4104 Send node,
4105 Node left,
4106 Node right,
4107 A arg) {
4108 apply(left, arg);
4109 apply(right, arg);
4110 return null;
4111 }
4112
4113 @override
4114 R visitNot(
4115 Send node,
4116 Node expression,
4117 A arg) {
4118 apply(expression, arg);
4119 return null;
4120 }
4121
4122 @override
4123 R visitNotEquals(
4124 Send node,
4125 Node left,
4126 Node right,
4127 A arg) {
4128 apply(left, arg);
4129 apply(right, arg);
4130 return null;
4131 }
4132
4133 @override
4134 R visitParameterCompound(
4135 Send node,
4136 ParameterElement parameter,
4137 AssignmentOperator operator,
4138 Node rhs,
4139 A arg) {
4140 apply(rhs, arg);
4141 return null;
4142 }
4143
4144 @override
4145 R visitParameterGet(
4146 Send node,
4147 ParameterElement parameter,
4148 A arg) { 4277 A arg) {
4149 return null; 4278 return null;
4150 } 4279 }
4151 4280
4152 @override 4281 @override
4153 R visitParameterInvoke( 4282 R visitThisGet(Identifier node, A arg) {
4283 return null;
4284 }
4285
4286 @override
4287 R visitThisInvoke(
4154 Send node, 4288 Send node,
4155 ParameterElement parameter,
4156 NodeList arguments, 4289 NodeList arguments,
4157 CallStructure callStructure, 4290 CallStructure callStructure,
4158 A arg) { 4291 A arg) {
4159 apply(arguments, arg); 4292 apply(arguments, arg);
4160 return null; 4293 return null;
4161 } 4294 }
4162 4295
4163 @override 4296 @override
4164 R visitParameterPostfix( 4297 R visitThisPropertyCompound(
4165 Send node, 4298 Send node,
4166 ParameterElement parameter, 4299 AssignmentOperator operator,
4167 IncDecOperator operator, 4300 Node rhs,
4301 Selector getterSelector,
4302 Selector setterSelector,
4303 A arg) {
4304 apply(rhs, arg);
4305 return null;
4306 }
4307
4308 @override
4309 R visitThisPropertyGet(
4310 Send node,
4311 Selector selector,
4168 A arg) { 4312 A arg) {
4169 return null; 4313 return null;
4170 } 4314 }
4171 4315
4172 @override 4316 @override
4173 R visitParameterPrefix( 4317 R visitThisPropertyInvoke(
4174 Send node, 4318 Send node,
4175 ParameterElement parameter, 4319 NodeList arguments,
4320 Selector selector,
4321 A arg) {
4322 apply(arguments, arg);
4323 return null;
4324 }
4325
4326 @override
4327 R visitThisPropertyPostfix(
4328 Send node,
4176 IncDecOperator operator, 4329 IncDecOperator operator,
4330 Selector getterSelector,
4331 Selector setterSelector,
4177 A arg) { 4332 A arg) {
4178 return null; 4333 return null;
4179 } 4334 }
4180 4335
4181 @override 4336 @override
4182 R visitParameterSet( 4337 R visitThisPropertyPrefix(
4338 Send node,
4339 IncDecOperator operator,
4340 Selector getterSelector,
4341 Selector setterSelector,
4342 A arg) {
4343 return null;
4344 }
4345
4346 @override
4347 R visitThisPropertySet(
4183 SendSet node, 4348 SendSet node,
4184 ParameterElement parameter, 4349 Selector selector,
4185 Node rhs, 4350 Node rhs,
4186 A arg) { 4351 A arg) {
4187 apply(rhs, arg); 4352 apply(rhs, arg);
4188 return null; 4353 return null;
4189 } 4354 }
4190 4355
4191 @override 4356 @override
4192 R visitStaticFieldCompound( 4357 R visitTopLevelFieldCompound(
4193 Send node, 4358 Send node,
4194 FieldElement field, 4359 FieldElement field,
4195 AssignmentOperator operator, 4360 AssignmentOperator operator,
4196 Node rhs, 4361 Node rhs,
4197 A arg) { 4362 A arg) {
4198 apply(rhs, arg); 4363 apply(rhs, arg);
4199 return null; 4364 return null;
4200 } 4365 }
4201 4366
4202 @override 4367 @override
4203 R visitStaticFieldGet( 4368 R visitTopLevelFieldGet(
4204 Send node, 4369 Send node,
4205 FieldElement field, 4370 FieldElement field,
4206 A arg) { 4371 A arg) {
4207 return null; 4372 return null;
4208 } 4373 }
4209 4374
4210 @override 4375 @override
4211 R visitStaticFieldInvoke( 4376 R visitTopLevelFieldInvoke(
4212 Send node, 4377 Send node,
4213 FieldElement field, 4378 FieldElement field,
4214 NodeList arguments, 4379 NodeList arguments,
4215 CallStructure callStructure, 4380 CallStructure callStructure,
4216 A arg) { 4381 A arg) {
4217 apply(arguments, arg); 4382 apply(arguments, arg);
4218 return null; 4383 return null;
4219 } 4384 }
4220 4385
4221 @override 4386 @override
4222 R visitStaticFieldPostfix( 4387 R visitTopLevelFieldPostfix(
4223 Send node, 4388 Send node,
4224 FieldElement field, 4389 FieldElement field,
4225 IncDecOperator operator, 4390 IncDecOperator operator,
4226 A arg) { 4391 A arg) {
4227 return null; 4392 return null;
4228 } 4393 }
4229 4394
4230 @override 4395 @override
4231 R visitStaticFieldPrefix( 4396 R visitTopLevelFieldPrefix(
4232 Send node, 4397 Send node,
4233 FieldElement field, 4398 FieldElement field,
4234 IncDecOperator operator, 4399 IncDecOperator operator,
4235 A arg) { 4400 A arg) {
4236 return null; 4401 return null;
4237 } 4402 }
4238 4403
4239 @override 4404 @override
4240 R visitStaticFieldSet( 4405 R visitTopLevelFieldSet(
4241 SendSet node, 4406 SendSet node,
4242 FieldElement field, 4407 FieldElement field,
4243 Node rhs, 4408 Node rhs,
4244 A arg) { 4409 A arg) {
4245 apply(rhs, arg); 4410 apply(rhs, arg);
4246 return null; 4411 return null;
4247 } 4412 }
4248 4413
4249 @override 4414 @override
4250 R visitStaticFunctionGet( 4415 R visitTopLevelFunctionGet(
4251 Send node, 4416 Send node,
4252 MethodElement function, 4417 MethodElement function,
4253 A arg) { 4418 A arg) {
4254 return null; 4419 return null;
4255 } 4420 }
4256 4421
4257 @override 4422 @override
4258 R visitStaticFunctionInvoke( 4423 R visitTopLevelFunctionInvoke(
4259 Send node, 4424 Send node,
4260 MethodElement function, 4425 MethodElement function,
4261 NodeList arguments, 4426 NodeList arguments,
4262 CallStructure callStructure, 4427 CallStructure callStructure,
4263 A arg) { 4428 A arg) {
4264 apply(arguments, arg); 4429 apply(arguments, arg);
4265 return null; 4430 return null;
4266 } 4431 }
4267 4432
4268 @override 4433 @override
4269 R visitStaticFunctionIncompatibleInvoke( 4434 R visitTopLevelFunctionIncompatibleInvoke(
4270 Send node, 4435 Send node,
4271 MethodElement function, 4436 MethodElement function,
4272 NodeList arguments, 4437 NodeList arguments,
4273 CallStructure callStructure, 4438 CallStructure callStructure,
4274 A arg) { 4439 A arg) {
4275 apply(arguments, arg); 4440 apply(arguments, arg);
4276 return null; 4441 return null;
4277 } 4442 }
4278 4443
4279 @override 4444 @override
4280 R visitStaticGetterGet( 4445 R visitTopLevelGetterGet(
4281 Send node, 4446 Send node,
4282 FunctionElement getter, 4447 FunctionElement getter,
4283 A arg) { 4448 A arg) {
4284 return null; 4449 return null;
4285 } 4450 }
4286 4451
4287 @override 4452 @override
4288 R visitStaticGetterInvoke( 4453 R visitTopLevelGetterInvoke(
4289 Send node, 4454 Send node,
4290 FunctionElement getter, 4455 FunctionElement getter,
4291 NodeList arguments, 4456 NodeList arguments,
4292 CallStructure callStructure, 4457 CallStructure callStructure,
4293 A arg) { 4458 A arg) {
4294 apply(arguments, arg); 4459 apply(arguments, arg);
4295 return null; 4460 return null;
4296 } 4461 }
4297 4462
4298 @override 4463 @override
4299 R visitStaticGetterSetterCompound( 4464 R visitTopLevelGetterSetterCompound(
4300 Send node, 4465 Send node,
4301 FunctionElement getter, 4466 FunctionElement getter,
4302 FunctionElement setter, 4467 FunctionElement setter,
4303 AssignmentOperator operator, 4468 AssignmentOperator operator,
4304 Node rhs, 4469 Node rhs,
4305 A arg) { 4470 A arg) {
4306 apply(rhs, arg); 4471 apply(rhs, arg);
4307 return null; 4472 return null;
4308 } 4473 }
4309 4474
4310 @override 4475 @override
4311 R visitStaticGetterSetterPostfix( 4476 R visitTopLevelGetterSetterPostfix(
4312 Send node, 4477 Send node,
4313 FunctionElement getter, 4478 FunctionElement getter,
4314 FunctionElement setter, 4479 FunctionElement setter,
4315 IncDecOperator operator, 4480 IncDecOperator operator,
4316 A arg) { 4481 A arg) {
4317 return null; 4482 return null;
4318 } 4483 }
4319 4484
4320 @override 4485 @override
4321 R visitStaticGetterSetterPrefix( 4486 R visitTopLevelGetterSetterPrefix(
4322 Send node, 4487 Send node,
4323 FunctionElement getter, 4488 FunctionElement getter,
4324 FunctionElement setter, 4489 FunctionElement setter,
4325 IncDecOperator operator, 4490 IncDecOperator operator,
4326 A arg) { 4491 A arg) {
4327 return null; 4492 return null;
4328 } 4493 }
4329 4494
4330 @override 4495 @override
4331 R visitStaticMethodSetterCompound( 4496 R visitTopLevelMethodSetterCompound(
4332 Send node, 4497 Send node,
4333 FunctionElement method, 4498 FunctionElement method,
4334 FunctionElement setter, 4499 FunctionElement setter,
4335 AssignmentOperator operator, 4500 AssignmentOperator operator,
4336 Node rhs, 4501 Node rhs,
4337 A arg) { 4502 A arg) {
4338 apply(rhs, arg); 4503 apply(rhs, arg);
4339 return null; 4504 return null;
4340 } 4505 }
4341 4506
4342 @override 4507 @override
4343 R visitStaticMethodSetterPostfix( 4508 R visitTopLevelMethodSetterPostfix(
4344 Send node, 4509 Send node,
4345 FunctionElement getter, 4510 FunctionElement method,
4346 FunctionElement setter, 4511 FunctionElement setter,
4347 IncDecOperator operator, 4512 IncDecOperator operator,
4348 A arg) { 4513 A arg) {
4349 return null; 4514 return null;
4350 } 4515 }
4351 4516
4352 @override 4517 @override
4353 R visitStaticMethodSetterPrefix( 4518 R visitTopLevelMethodSetterPrefix(
4354 Send node, 4519 Send node,
4355 FunctionElement getter, 4520 FunctionElement method,
4356 FunctionElement setter, 4521 FunctionElement setter,
4357 IncDecOperator operator, 4522 IncDecOperator operator,
4358 A arg) { 4523 A arg) {
4359 return null; 4524 return null;
4360 } 4525 }
4361 4526
4362 @override 4527 @override
4363 R visitStaticSetterSet( 4528 R visitTopLevelSetterSet(
4364 SendSet node, 4529 SendSet node,
4365 FunctionElement setter, 4530 FunctionElement setter,
4366 Node rhs, 4531 Node rhs,
4367 A arg) { 4532 A arg) {
4368 apply(rhs, arg); 4533 apply(rhs, arg);
4369 return null; 4534 return null;
4370 } 4535 }
4371 4536
4372 @override 4537 @override
4373 R visitSuperBinary( 4538 R errorTypeVariableTypeLiteralCompound(
4374 Send node, 4539 Send node,
4375 FunctionElement function, 4540 TypeVariableElement element,
4376 BinaryOperator operator,
4377 Node argument,
4378 A arg) {
4379 apply(argument, arg);
4380 return null;
4381 }
4382
4383 @override
4384 R visitSuperCompoundIndexSet(
4385 SendSet node,
4386 FunctionElement getter,
4387 FunctionElement setter,
4388 Node index,
4389 AssignmentOperator operator, 4541 AssignmentOperator operator,
4390 Node rhs, 4542 Node rhs,
4391 A arg) { 4543 A arg) {
4392 apply(rhs, arg); 4544 apply(rhs, arg);
4393 return null; 4545 return null;
4394 } 4546 }
4395 4547
4396 @override 4548 @override
4397 R visitSuperEquals( 4549 R visitTypeVariableTypeLiteralGet(
4398 Send node, 4550 Send node,
4399 FunctionElement function, 4551 TypeVariableElement element,
4400 Node argument,
4401 A arg) { 4552 A arg) {
4402 apply(argument, arg);
4403 return null; 4553 return null;
4404 } 4554 }
4405 4555
4406 @override 4556 @override
4407 R visitSuperFieldCompound( 4557 R visitTypeVariableTypeLiteralInvoke(
4408 Send node, 4558 Send node,
4409 FieldElement field, 4559 TypeVariableElement element,
4560 NodeList arguments,
4561 CallStructure callStructure,
4562 A arg) {
4563 apply(arguments, arg);
4564 return null;
4565 }
4566
4567 @override
4568 R errorTypeVariableTypeLiteralPostfix(
4569 Send node,
4570 TypeVariableElement element,
4571 IncDecOperator operator,
4572 A arg) {
4573 return null;
4574 }
4575
4576 @override
4577 R errorTypeVariableTypeLiteralPrefix(
4578 Send node,
4579 TypeVariableElement element,
4580 IncDecOperator operator,
4581 A arg) {
4582 return null;
4583 }
4584
4585 @override
4586 R errorTypedefTypeLiteralCompound(
4587 Send node,
4588 ConstantExpression constant,
4410 AssignmentOperator operator, 4589 AssignmentOperator operator,
4411 Node rhs, 4590 Node rhs,
4412 A arg) { 4591 A arg) {
4413 apply(rhs, arg); 4592 apply(rhs, arg);
4414 return null; 4593 return null;
4415 } 4594 }
4416 4595
4417 @override 4596 @override
4418 R visitSuperFieldFieldPostfix( 4597 R visitTypedefTypeLiteralGet(
4419 Send node, 4598 Send node,
4420 FieldElement readField, 4599 ConstantExpression constant,
4421 FieldElement writtenField,
4422 IncDecOperator operator,
4423 A arg) { 4600 A arg) {
4424 return null; 4601 return null;
4425 } 4602 }
4426 4603
4427 @override 4604 @override
4428 R visitSuperFieldFieldPrefix( 4605 R visitTypedefTypeLiteralInvoke(
4429 Send node, 4606 Send node,
4430 FieldElement readField, 4607 ConstantExpression constant,
4431 FieldElement writtenField,
4432 IncDecOperator operator,
4433 A arg) {
4434 return null;
4435 }
4436
4437 @override
4438 R visitSuperFieldGet(
4439 Send node,
4440 FieldElement field,
4441 A arg) {
4442 return null;
4443 }
4444
4445 @override
4446 R visitSuperFieldInvoke(
4447 Send node,
4448 FieldElement field,
4449 NodeList arguments, 4608 NodeList arguments,
4450 CallStructure callStructure, 4609 CallStructure callStructure,
4451 A arg) { 4610 A arg) {
4452 apply(arguments, arg); 4611 apply(arguments, arg);
4453 return null; 4612 return null;
4454 } 4613 }
4455 4614
4456 @override 4615 @override
4457 R visitSuperFieldPostfix( 4616 R errorTypedefTypeLiteralPostfix(
4458 Send node, 4617 Send node,
4459 FieldElement field, 4618 ConstantExpression constant,
4460 IncDecOperator operator, 4619 IncDecOperator operator,
4461 A arg) { 4620 A arg) {
4462 return null; 4621 return null;
4463 } 4622 }
4464 4623
4465 @override 4624 @override
4466 R visitSuperFieldPrefix( 4625 R errorTypedefTypeLiteralPrefix(
4467 Send node, 4626 Send node,
4468 FieldElement field, 4627 ConstantExpression constant,
4469 IncDecOperator operator, 4628 IncDecOperator operator,
4470 A arg) { 4629 A arg) {
4471 return null; 4630 return null;
4472 } 4631 }
4473 4632
4474 @override 4633 @override
4475 R visitSuperFieldSet( 4634 R visitUnary(
4476 SendSet node, 4635 Send node,
4477 FieldElement field, 4636 UnaryOperator operator,
4478 Node rhs, 4637 Node expression,
4479 A arg) { 4638 A arg) {
4480 apply(rhs, arg); 4639 apply(expression, arg);
4481 return null; 4640 return null;
4482 } 4641 }
4483 4642
4484 @override 4643 @override
4485 R visitSuperFieldSetterCompound( 4644 R errorUnresolvedCompound(
4486 Send node, 4645 Send node,
4487 FieldElement field, 4646 Element element,
4488 FunctionElement setter,
4489 AssignmentOperator operator, 4647 AssignmentOperator operator,
4490 Node rhs, 4648 Node rhs,
4491 A arg) { 4649 A arg) {
4492 apply(rhs, arg); 4650 apply(rhs, arg);
4493 return null; 4651 return null;
4494 } 4652 }
4495 4653
4496 @override 4654 @override
4497 R visitSuperFieldSetterPostfix( 4655 R visitUnresolvedGet(
4498 Send node, 4656 Send node,
4499 FieldElement field, 4657 Element element,
4500 FunctionElement setter, 4658 A arg) {
4659 return null;
4660 }
4661
4662 @override
4663 R visitUnresolvedInvoke(
4664 Send node,
4665 Element element,
4666 NodeList arguments,
4667 Selector selector,
4668 A arg) {
4669 apply(arguments, arg);
4670 return null;
4671 }
4672
4673 @override
4674 R errorUnresolvedPostfix(
4675 Send node,
4676 Element element,
4501 IncDecOperator operator, 4677 IncDecOperator operator,
4502 A arg) { 4678 A arg) {
4503 return null; 4679 return null;
4504 } 4680 }
4505 4681
4506 @override 4682 @override
4507 R visitSuperFieldSetterPrefix( 4683 R errorUnresolvedPrefix(
4508 Send node, 4684 Send node,
4509 FieldElement field, 4685 Element element,
4510 FunctionElement setter,
4511 IncDecOperator operator, 4686 IncDecOperator operator,
4512 A arg) { 4687 A arg) {
4513 return null; 4688 return null;
4514 } 4689 }
4515 4690
4516 @override 4691 @override
4517 R visitSuperGetterFieldCompound( 4692 R errorUnresolvedSet(
4518 Send node, 4693 Send node,
4519 FunctionElement getter, 4694 Element element,
4520 FieldElement field,
4521 AssignmentOperator operator,
4522 Node rhs, 4695 Node rhs,
4523 A arg) { 4696 A arg) {
4524 apply(rhs, arg); 4697 apply(rhs, arg);
4525 return null; 4698 return null;
4526 } 4699 }
4527 4700
4528 @override 4701 @override
4529 R visitSuperGetterFieldPostfix( 4702 R errorUndefinedBinaryExpression(
4530 Send node, 4703 Send node,
4531 FunctionElement getter, 4704 Node left,
4532 FieldElement field, 4705 Operator operator,
4533 IncDecOperator operator, 4706 Node right,
4534 A arg) { 4707 A arg) {
4708 apply(left, arg);
4709 apply(right, arg);
4535 return null; 4710 return null;
4536 } 4711 }
4537 4712
4538 @override 4713 @override
4539 R visitSuperGetterFieldPrefix( 4714 R errorUndefinedUnaryExpression(
4540 Send node, 4715 Send node,
4541 FunctionElement getter, 4716 Operator operator,
4542 FieldElement field, 4717 Node expression,
4543 IncDecOperator operator,
4544 A arg) { 4718 A arg) {
4719 apply(expression, arg);
4545 return null; 4720 return null;
4546 } 4721 }
4547 4722
4548 @override 4723 @override
4549 R visitSuperGetterGet( 4724 R visitUnresolvedSuperIndexSet(
4550 Send node, 4725 Send node,
4551 FunctionElement getter, 4726 Element element,
4552 A arg) { 4727 Node index,
4553 return null;
4554 }
4555
4556 @override
4557 R visitSuperGetterInvoke(
4558 Send node,
4559 FunctionElement getter,
4560 NodeList arguments,
4561 CallStructure callStructure,
4562 A arg) {
4563 apply(arguments, arg);
4564 return null;
4565 }
4566
4567 @override
4568 R visitSuperGetterSetterCompound(
4569 Send node,
4570 FunctionElement getter,
4571 FunctionElement setter,
4572 AssignmentOperator operator,
4573 Node rhs, 4728 Node rhs,
4574 A arg) { 4729 A arg) {
4730 apply(index, arg);
4575 apply(rhs, arg); 4731 apply(rhs, arg);
4576 return null; 4732 return null;
4577 } 4733 }
4578 4734
4579 @override 4735 @override
4580 R visitSuperGetterSetterPostfix( 4736 R visitUnresolvedSuperGetterCompoundIndexSet(
4581 Send node, 4737 SendSet node,
4582 FunctionElement getter, 4738 Element element,
4583 FunctionElement setter, 4739 Node index,
4584 IncDecOperator operator, 4740 AssignmentOperator operator,
4741 Node rhs,
4585 A arg) { 4742 A arg) {
4743 apply(index, arg);
4744 apply(rhs, arg);
4586 return null; 4745 return null;
4587 } 4746 }
4588 4747
4589 @override 4748 @override
4590 R visitSuperGetterSetterPrefix( 4749 R visitUnresolvedSuperSetterCompoundIndexSet(
4591 Send node, 4750 SendSet node,
4592 FunctionElement getter, 4751 MethodElement getter,
4593 FunctionElement setter, 4752 Element element,
4594 IncDecOperator operator,
4595 A arg) {
4596 return null;
4597 }
4598
4599 @override
4600 R visitSuperIndex(
4601 Send node,
4602 FunctionElement function,
4603 Node index, 4753 Node index,
4604 A arg) { 4754 AssignmentOperator operator,
4605 apply(index, arg);
4606 return null;
4607 }
4608
4609 @override
4610 R visitSuperIndexSet(
4611 SendSet node,
4612 FunctionElement function,
4613 Node index,
4614 Node rhs, 4755 Node rhs,
4615 A arg) { 4756 A arg) {
4616 apply(index, arg); 4757 apply(index, arg);
4617 apply(rhs, arg); 4758 apply(rhs, arg);
4618 return null; 4759 return null;
4619 } 4760 }
4620 4761
4621 @override 4762 @override
4622 R visitSuperMethodGet( 4763 R visitUnresolvedSuperBinary(
4623 Send node, 4764 Send node,
4624 MethodElement method, 4765 Element element,
4625 A arg) { 4766 BinaryOperator operator,
4626 return null;
4627 }
4628
4629 @override
4630 R visitSuperMethodInvoke(
4631 Send node,
4632 MethodElement method,
4633 NodeList arguments,
4634 CallStructure callStructure,
4635 A arg) {
4636 apply(arguments, arg);
4637 return null;
4638 }
4639
4640 @override
4641 R visitSuperMethodIncompatibleInvoke(
4642 Send node,
4643 MethodElement method,
4644 NodeList arguments,
4645 CallStructure callStructure,
4646 A arg) {
4647 apply(arguments, arg);
4648 return null;
4649 }
4650
4651 @override
4652 R visitSuperMethodSetterCompound(
4653 Send node,
4654 FunctionElement method,
4655 FunctionElement setter,
4656 AssignmentOperator operator,
4657 Node rhs,
4658 A arg) {
4659 apply(rhs, arg);
4660 return null;
4661 }
4662
4663 @override
4664 R visitSuperMethodSetterPostfix(
4665 Send node,
4666 FunctionElement method,
4667 FunctionElement setter,
4668 IncDecOperator operator,
4669 A arg) {
4670 return null;
4671 }
4672
4673 @override
4674 R visitSuperMethodSetterPrefix(
4675 Send node,
4676 FunctionElement method,
4677 FunctionElement setter,
4678 IncDecOperator operator,
4679 A arg) {
4680 return null;
4681 }
4682
4683 @override
4684 R visitSuperNotEquals(
4685 Send node,
4686 FunctionElement function,
4687 Node argument, 4767 Node argument,
4688 A arg) { 4768 A arg) {
4689 apply(argument, arg); 4769 apply(argument, arg);
4690 return null; 4770 return null;
4691 } 4771 }
4692 4772
4693 @override 4773 @override
4694 R visitSuperSetterSet( 4774 R visitUnresolvedSuperUnary(
4695 SendSet node,
4696 FunctionElement setter,
4697 Node rhs,
4698 A arg) {
4699 apply(rhs, arg);
4700 return null;
4701 }
4702
4703 @override
4704 R visitSuperUnary(
4705 Send node, 4775 Send node,
4706 UnaryOperator operator, 4776 UnaryOperator operator,
4707 FunctionElement function, 4777 Element element,
4708 A arg) { 4778 A arg) {
4709 return null; 4779 return null;
4710 } 4780 }
4711 4781
4712 @override 4782 @override
4713 R visitThisGet(Identifier node, A arg) { 4783 R visitUnresolvedSuperGetterIndexPostfix(
4784 Send node,
4785 Element element,
4786 Node index,
4787 IncDecOperator operator,
4788 A arg) {
4789 apply(index, arg);
4714 return null; 4790 return null;
4715 } 4791 }
4716 4792
4717 @override 4793 @override
4718 R visitThisInvoke( 4794 R visitUnresolvedSuperSetterIndexPostfix(
4719 Send node, 4795 Send node,
4796 MethodElement getter,
4797 Element element,
4798 Node index,
4799 IncDecOperator operator,
4800 A arg) {
4801 apply(index, arg);
4802 return null;
4803 }
4804
4805 @override
4806 R visitUnresolvedSuperGetterIndexPrefix(
4807 Send node,
4808 Element element,
4809 Node index,
4810 IncDecOperator operator,
4811 A arg) {
4812 apply(index, arg);
4813 return null;
4814 }
4815
4816 @override
4817 R visitUnresolvedSuperSetterIndexPrefix(
4818 Send node,
4819 MethodElement getter,
4820 Element element,
4821 Node index,
4822 IncDecOperator operator,
4823 A arg) {
4824 apply(index, arg);
4825 return null;
4826 }
4827
4828 @override
4829 R visitIndexPostfix(
4830 Send node,
4831 Node receiver,
4832 Node index,
4833 IncDecOperator operator,
4834 A arg) {
4835 apply(receiver, arg);
4836 apply(index, arg);
4837 return null;
4838 }
4839
4840 @override
4841 R visitIndexPrefix(
4842 Send node,
4843 Node receiver,
4844 Node index,
4845 IncDecOperator operator,
4846 A arg) {
4847 apply(receiver, arg);
4848 apply(index, arg);
4849 return null;
4850 }
4851
4852 @override
4853 R visitSuperIndexPostfix(
4854 Send node,
4855 FunctionElement indexFunction,
4856 FunctionElement indexSetFunction,
4857 Node index,
4858 IncDecOperator operator,
4859 A arg) {
4860 apply(index, arg);
4861 return null;
4862 }
4863
4864 @override
4865 R visitSuperIndexPrefix(
4866 Send node,
4867 FunctionElement indexFunction,
4868 FunctionElement indexSetFunction,
4869 Node index,
4870 IncDecOperator operator,
4871 A arg) {
4872 apply(index, arg);
4873 return null;
4874 }
4875
4876 R visitConstConstructorInvoke(
4877 NewExpression node,
4878 ConstructedConstantExpression constant,
4879 A arg) {
4880 return null;
4881 }
4882
4883 @override
4884 R visitUnresolvedClassConstructorInvoke(
4885 NewExpression node,
4886 Element constructor,
4887 DartType type,
4720 NodeList arguments, 4888 NodeList arguments,
4721 CallStructure callStructure, 4889 Selector selector,
4722 A arg) { 4890 A arg) {
4723 apply(arguments, arg); 4891 apply(arguments, arg);
4724 return null; 4892 return null;
4725 } 4893 }
4726 4894
4727 @override 4895 @override
4728 R visitThisPropertyCompound( 4896 R visitUnresolvedConstructorInvoke(
4729 Send node, 4897 NewExpression node,
4730 AssignmentOperator operator, 4898 Element constructor,
4731 Node rhs, 4899 DartType type,
4732 Selector getterSelector,
4733 Selector setterSelector,
4734 A arg) {
4735 apply(rhs, arg);
4736 return null;
4737 }
4738
4739 @override
4740 R visitThisPropertyGet(
4741 Send node,
4742 Selector selector,
4743 A arg) {
4744 return null;
4745 }
4746
4747 @override
4748 R visitThisPropertyInvoke(
4749 Send node,
4750 NodeList arguments, 4900 NodeList arguments,
4751 Selector selector, 4901 Selector selector,
4752 A arg) { 4902 A arg) {
4753 apply(arguments, arg); 4903 apply(arguments, arg);
4754 return null; 4904 return null;
4755 } 4905 }
4756 4906
4757 @override 4907 @override
4758 R visitThisPropertyPostfix( 4908 R visitFactoryConstructorInvoke(
4759 Send node, 4909 NewExpression node,
4760 IncDecOperator operator, 4910 ConstructorElement constructor,
4761 Selector getterSelector, 4911 InterfaceType type,
4762 Selector setterSelector, 4912 NodeList arguments,
4913 CallStructure callStructure,
4763 A arg) { 4914 A arg) {
4915 apply(arguments, arg);
4764 return null; 4916 return null;
4765 } 4917 }
4766 4918
4767 @override 4919 @override
4768 R visitThisPropertyPrefix( 4920 R visitGenerativeConstructorInvoke(
4769 Send node, 4921 NewExpression node,
4770 IncDecOperator operator, 4922 ConstructorElement constructor,
4771 Selector getterSelector, 4923 InterfaceType type,
4772 Selector setterSelector, 4924 NodeList arguments,
4925 CallStructure callStructure,
4773 A arg) { 4926 A arg) {
4927 apply(arguments, arg);
4774 return null; 4928 return null;
4775 } 4929 }
4776 4930
4777 @override 4931 @override
4778 R visitThisPropertySet( 4932 R visitRedirectingFactoryConstructorInvoke(
4779 SendSet node, 4933 NewExpression node,
4780 Selector selector, 4934 ConstructorElement constructor,
4781 Node rhs, 4935 InterfaceType type,
4936 ConstructorElement effectiveTarget,
4937 InterfaceType effectiveTargetType,
4938 NodeList arguments,
4939 CallStructure callStructure,
4782 A arg) { 4940 A arg) {
4783 apply(rhs, arg); 4941 apply(arguments, arg);
4784 return null; 4942 return null;
4785 } 4943 }
4786 4944
4787 @override 4945 @override
4788 R visitTopLevelFieldCompound( 4946 R visitRedirectingGenerativeConstructorInvoke(
4789 Send node, 4947 NewExpression node,
4790 FieldElement field, 4948 ConstructorElement constructor,
4791 AssignmentOperator operator, 4949 InterfaceType type,
4792 Node rhs, 4950 NodeList arguments,
4951 CallStructure callStructure,
4793 A arg) { 4952 A arg) {
4794 apply(rhs, arg); 4953 apply(arguments, arg);
4795 return null; 4954 return null;
4796 } 4955 }
4797 4956
4798 @override 4957 @override
4799 R visitTopLevelFieldGet( 4958 R visitAbstractClassConstructorInvoke(
4800 Send node, 4959 NewExpression node,
4801 FieldElement field, 4960 ConstructorElement element,
4961 InterfaceType type,
4962 NodeList arguments,
4963 CallStructure callStructure,
4802 A arg) { 4964 A arg) {
4965 apply(arguments, arg);
4803 return null; 4966 return null;
4804 } 4967 }
4805 4968
4806 @override 4969 @override
4807 R visitTopLevelFieldInvoke( 4970 R visitUnresolvedRedirectingFactoryConstructorInvoke(
4808 Send node, 4971 NewExpression node,
4809 FieldElement field, 4972 ConstructorElement constructor,
4973 InterfaceType type,
4810 NodeList arguments, 4974 NodeList arguments,
4811 CallStructure callStructure, 4975 CallStructure callStructure,
4812 A arg) { 4976 A arg) {
4813 apply(arguments, arg); 4977 apply(arguments, arg);
4814 return null; 4978 return null;
4815 } 4979 }
4816 4980
4817 @override 4981 @override
4818 R visitTopLevelFieldPostfix( 4982 R errorNonConstantConstructorInvoke(
4819 Send node, 4983 NewExpression node,
4820 FieldElement field, 4984 Element element,
4821 IncDecOperator operator, 4985 DartType type,
4822 A arg) { 4986 NodeList arguments,
4823 return null; 4987 CallStructure callStructure,
4824 } 4988 A arg) {
4825 4989 apply(arguments, arg);
4826 @override 4990 return null;
4827 R visitTopLevelFieldPrefix( 4991 }
4828 Send node, 4992 }
4829 FieldElement field, 4993
4830 IncDecOperator operator, 4994 /// [SemanticDeclarationVisitor] that visits subnodes.
4831 A arg) { 4995 class TraversalDeclarationMixin<R, A>
4832 return null; 4996 implements SemanticDeclarationVisitor<R, A> {
4833 } 4997 @override
4834 4998 R apply(Node node, A arg) {
4835 @override 4999 throw new UnimplementedError("TraversalMixin.apply unimplemented");
4836 R visitTopLevelFieldSet( 5000 }
5001
5002 @override
5003 applyInitializers(NodeList initializers, A arg) {
5004 throw new UnimplementedError(
5005 "TraversalMixin.applyInitializers unimplemented");
5006 }
5007
5008 @override
5009 applyParameters(NodeList parameters, A arg) {
5010 throw new UnimplementedError(
5011 "TraversalMixin.applyParameters unimplemented");
5012 }
5013
5014 @override
5015 R visitAbstractMethodDeclaration(
5016 FunctionExpression node,
5017 MethodElement method,
5018 NodeList parameters,
5019 A arg) {
5020 applyParameters(parameters, arg);
5021 return null;
5022 }
5023
5024 @override
5025 R visitClosureDeclaration(
5026 FunctionExpression node,
5027 LocalFunctionElement function,
5028 NodeList parameters,
5029 Node body,
5030 A arg) {
5031 applyParameters(parameters, arg);
5032 apply(body, arg);
5033 return null;
5034 }
5035
5036 @override
5037 R visitFactoryConstructorDeclaration(
5038 FunctionExpression node,
5039 ConstructorElement constructor,
5040 NodeList parameters,
5041 Node body,
5042 A arg) {
5043 applyParameters(parameters, arg);
5044 apply(body, arg);
5045 return null;
5046 }
5047
5048 @override
5049 R visitFieldInitializer(
4837 SendSet node, 5050 SendSet node,
4838 FieldElement field, 5051 FieldElement field,
4839 Node rhs, 5052 Node initializer,
4840 A arg) { 5053 A arg) {
4841 apply(rhs, arg); 5054 apply(initializer, arg);
4842 return null; 5055 return null;
4843 } 5056 }
4844 5057
4845 @override 5058 @override
4846 R visitTopLevelFunctionGet( 5059 R visitGenerativeConstructorDeclaration(
5060 FunctionExpression node,
5061 ConstructorElement constructor,
5062 NodeList parameters,
5063 NodeList initializers,
5064 Node body,
5065 A arg) {
5066 applyParameters(parameters, arg);
5067 applyInitializers(initializers, arg);
5068 apply(body, arg);
5069 return null;
5070 }
5071
5072 @override
5073 R visitInstanceMethodDeclaration(
5074 FunctionExpression node,
5075 MethodElement method,
5076 NodeList parameters,
5077 Node body,
5078 A arg) {
5079 applyParameters(parameters, arg);
5080 apply(body, arg);
5081 return null;
5082 }
5083
5084 @override
5085 R visitLocalFunctionDeclaration(
5086 FunctionExpression node,
5087 LocalFunctionElement function,
5088 NodeList parameters,
5089 Node body,
5090 A arg) {
5091 applyParameters(parameters, arg);
5092 apply(body, arg);
5093 return null;
5094 }
5095
5096 @override
5097 R visitRedirectingFactoryConstructorDeclaration(
5098 FunctionExpression node,
5099 ConstructorElement constructor,
5100 NodeList parameters,
5101 InterfaceType redirectionType,
5102 ConstructorElement redirectionTarget,
5103 A arg) {
5104 applyParameters(parameters, arg);
5105 return null;
5106 }
5107
5108 @override
5109 R visitRedirectingGenerativeConstructorDeclaration(
5110 FunctionExpression node,
5111 ConstructorElement constructor,
5112 NodeList parameters,
5113 NodeList initializers,
5114 A arg) {
5115 applyParameters(parameters, arg);
5116 applyInitializers(initializers, arg);
5117 return null;
5118 }
5119
5120 @override
5121 R visitStaticFunctionDeclaration(
5122 FunctionExpression node,
5123 MethodElement function,
5124 NodeList parameters,
5125 Node body,
5126 A arg) {
5127 applyParameters(parameters, arg);
5128 apply(body, arg);
5129 return null;
5130 }
5131
5132 @override
5133 R visitSuperConstructorInvoke(
4847 Send node, 5134 Send node,
5135 ConstructorElement superConstructor,
5136 InterfaceType type,
5137 NodeList arguments,
5138 Selector selector,
5139 A arg) {
5140 apply(arguments, arg);
5141 return null;
5142 }
5143
5144 @override
5145 R visitThisConstructorInvoke(
5146 Send node,
5147 ConstructorElement thisConstructor,
5148 NodeList arguments,
5149 Selector selector,
5150 A arg) {
5151 apply(arguments, arg);
5152 return null;
5153 }
5154
5155 @override
5156 R visitTopLevelFunctionDeclaration(
5157 FunctionExpression node,
4848 MethodElement function, 5158 MethodElement function,
4849 A arg) { 5159 NodeList parameters,
4850 return null; 5160 Node body,
4851 } 5161 A arg) {
4852 5162 applyParameters(parameters, arg);
4853 @override 5163 apply(body, arg);
4854 R visitTopLevelFunctionInvoke( 5164 return null;
4855 Send node, 5165 }
4856 MethodElement function, 5166
4857 NodeList arguments, 5167 @override
4858 CallStructure callStructure, 5168 R errorUnresolvedFieldInitializer(
4859 A arg) {
4860 apply(arguments, arg);
4861 return null;
4862 }
4863
4864 @override
4865 R visitTopLevelFunctionIncompatibleInvoke(
4866 Send node,
4867 MethodElement function,
4868 NodeList arguments,
4869 CallStructure callStructure,
4870 A arg) {
4871 apply(arguments, arg);
4872 return null;
4873 }
4874
4875 @override
4876 R visitTopLevelGetterGet(
4877 Send node,
4878 FunctionElement getter,
4879 A arg) {
4880 return null;
4881 }
4882
4883 @override
4884 R visitTopLevelGetterInvoke(
4885 Send node,
4886 FunctionElement getter,
4887 NodeList arguments,
4888 CallStructure callStructure,
4889 A arg) {
4890 apply(arguments, arg);
4891 return null;
4892 }
4893
4894 @override
4895 R visitTopLevelGetterSetterCompound(
4896 Send node,
4897 FunctionElement getter,
4898 FunctionElement setter,
4899 AssignmentOperator operator,
4900 Node rhs,
4901 A arg) {
4902 apply(rhs, arg);
4903 return null;
4904 }
4905
4906 @override
4907 R visitTopLevelGetterSetterPostfix(
4908 Send node,
4909 FunctionElement getter,
4910 FunctionElement setter,
4911 IncDecOperator operator,
4912 A arg) {
4913 return null;
4914 }
4915
4916 @override
4917 R visitTopLevelGetterSetterPrefix(
4918 Send node,
4919 FunctionElement getter,
4920 FunctionElement setter,
4921 IncDecOperator operator,
4922 A arg) {
4923 return null;
4924 }
4925
4926 @override
4927 R visitTopLevelMethodSetterCompound(
4928 Send node,
4929 FunctionElement method,
4930 FunctionElement setter,
4931 AssignmentOperator operator,
4932 Node rhs,
4933 A arg) {
4934 apply(rhs, arg);
4935 return null;
4936 }
4937
4938 @override
4939 R visitTopLevelMethodSetterPostfix(
4940 Send node,
4941 FunctionElement method,
4942 FunctionElement setter,
4943 IncDecOperator operator,
4944 A arg) {
4945 return null;
4946 }
4947
4948 @override
4949 R visitTopLevelMethodSetterPrefix(
4950 Send node,
4951 FunctionElement method,
4952 FunctionElement setter,
4953 IncDecOperator operator,
4954 A arg) {
4955 return null;
4956 }
4957
4958 @override
4959 R visitTopLevelSetterSet(
4960 SendSet node, 5169 SendSet node,
4961 FunctionElement setter, 5170 Element element,
4962 Node rhs, 5171 Node initializer,
4963 A arg) { 5172 A arg) {
4964 apply(rhs, arg); 5173 apply(initializer, arg);
4965 return null; 5174 return null;
4966 } 5175 }
4967 5176
4968 @override 5177 @override
4969 R visitTypeVariableTypeLiteralCompound( 5178 R errorUnresolvedSuperConstructorInvoke(
4970 Send node,
4971 TypeVariableElement element,
4972 AssignmentOperator operator,
4973 Node rhs,
4974 A arg) {
4975 apply(rhs, arg);
4976 return null;
4977 }
4978
4979 @override
4980 R visitTypeVariableTypeLiteralGet(
4981 Send node,
4982 TypeVariableElement element,
4983 A arg) {
4984 return null;
4985 }
4986
4987 @override
4988 R visitTypeVariableTypeLiteralInvoke(
4989 Send node,
4990 TypeVariableElement element,
4991 NodeList arguments,
4992 CallStructure callStructure,
4993 A arg) {
4994 apply(arguments, arg);
4995 return null;
4996 }
4997
4998 @override
4999 R visitTypeVariableTypeLiteralPostfix(
5000 Send node,
5001 TypeVariableElement element,
5002 IncDecOperator operator,
5003 A arg) {
5004 return null;
5005 }
5006
5007 @override
5008 R visitTypeVariableTypeLiteralPrefix(
5009 Send node,
5010 TypeVariableElement element,
5011 IncDecOperator operator,
5012 A arg) {
5013 return null;
5014 }
5015
5016 @override
5017 R visitTypedefTypeLiteralCompound(
5018 Send node,
5019 ConstantExpression constant,
5020 AssignmentOperator operator,
5021 Node rhs,
5022 A arg) {
5023 apply(rhs, arg);
5024 return null;
5025 }
5026
5027 @override
5028 R visitTypedefTypeLiteralGet(
5029 Send node,
5030 ConstantExpression constant,
5031 A arg) {
5032 return null;
5033 }
5034
5035 @override
5036 R visitTypedefTypeLiteralInvoke(
5037 Send node,
5038 ConstantExpression constant,
5039 NodeList arguments,
5040 CallStructure callStructure,
5041 A arg) {
5042 apply(arguments, arg);
5043 return null;
5044 }
5045
5046 @override
5047 R visitTypedefTypeLiteralPostfix(
5048 Send node,
5049 ConstantExpression constant,
5050 IncDecOperator operator,
5051 A arg) {
5052 return null;
5053 }
5054
5055 @override
5056 R visitTypedefTypeLiteralPrefix(
5057 Send node,
5058 ConstantExpression constant,
5059 IncDecOperator operator,
5060 A arg) {
5061 return null;
5062 }
5063
5064 @override
5065 R visitUnary(
5066 Send node,
5067 UnaryOperator operator,
5068 Node expression,
5069 A arg) {
5070 apply(expression, arg);
5071 return null;
5072 }
5073
5074 @override
5075 R visitUnresolvedCompound(
5076 Send node, 5179 Send node,
5077 Element element, 5180 Element element,
5078 AssignmentOperator operator, 5181 NodeList arguments,
5079 Node rhs,
5080 A arg) {
5081 apply(rhs, arg);
5082 return null;
5083 }
5084
5085 @override
5086 R visitUnresolvedGet(
5087 Send node,
5088 Element element,
5089 A arg) {
5090 return null;
5091 }
5092
5093 @override
5094 R visitUnresolvedInvoke(
5095 Send node,
5096 Element element,
5097 NodeList arguments,
5098 Selector selector, 5182 Selector selector,
5099 A arg) { 5183 A arg) {
5100 apply(arguments, arg); 5184 apply(arguments, arg);
5101 return null; 5185 return null;
5102 } 5186 }
5103 5187
5104 @override 5188 @override
5105 R visitUnresolvedPostfix(
5106 Send node,
5107 Element element,
5108 IncDecOperator operator,
5109 A arg) {
5110 return null;
5111 }
5112
5113 @override
5114 R visitUnresolvedPrefix(
5115 Send node,
5116 Element element,
5117 IncDecOperator operator,
5118 A arg) {
5119 return null;
5120 }
5121
5122 @override
5123 R errorUnresolvedSet(
5124 Send node,
5125 Element element,
5126 Node rhs,
5127 A arg) {
5128 apply(rhs, arg);
5129 return null;
5130 }
5131
5132 @override
5133 R errorUndefinedBinaryExpression(
5134 Send node,
5135 Node left,
5136 Operator operator,
5137 Node right,
5138 A arg) {
5139 apply(left, arg);
5140 apply(right, arg);
5141 return null;
5142 }
5143
5144 @override
5145 R errorUndefinedUnaryExpression(
5146 Send node,
5147 Operator operator,
5148 Node expression,
5149 A arg) {
5150 apply(expression, arg);
5151 return null;
5152 }
5153
5154 @override
5155 R visitUnresolvedSuperIndexSet(
5156 Send node,
5157 Element element,
5158 Node index,
5159 Node rhs,
5160 A arg) {
5161 apply(index, arg);
5162 apply(rhs, arg);
5163 return null;
5164 }
5165
5166 @override
5167 R visitUnresolvedSuperGetterCompoundIndexSet(
5168 SendSet node,
5169 Element element,
5170 MethodElement setter,
5171 Node index,
5172 AssignmentOperator operator,
5173 Node rhs,
5174 A arg) {
5175 apply(index, arg);
5176 apply(rhs, arg);
5177 return null;
5178 }
5179
5180 @override
5181 R visitUnresolvedSuperSetterCompoundIndexSet(
5182 SendSet node,
5183 MethodElement getter,
5184 Element element,
5185 Node index,
5186 AssignmentOperator operator,
5187 Node rhs,
5188 A arg) {
5189 apply(index, arg);
5190 apply(rhs, arg);
5191 return null;
5192 }
5193
5194 @override
5195 R visitUnresolvedSuperCompoundIndexSet(
5196 SendSet node,
5197 Element element,
5198 Node index,
5199 AssignmentOperator operator,
5200 Node rhs,
5201 A arg) {
5202 apply(index, arg);
5203 apply(rhs, arg);
5204 return null;
5205 }
5206
5207 @override
5208 R visitUnresolvedSuperBinary(
5209 Send node,
5210 Element element,
5211 BinaryOperator operator,
5212 Node argument,
5213 A arg) {
5214 apply(argument, arg);
5215 return null;
5216 }
5217
5218 @override
5219 R visitUnresolvedSuperUnary(
5220 Send node,
5221 UnaryOperator operator,
5222 Element element,
5223 A arg) {
5224 return null;
5225 }
5226
5227 @override
5228 R visitUnresolvedSuperGetterIndexPostfix(
5229 Send node,
5230 Element element,
5231 MethodElement setter,
5232 Node index,
5233 IncDecOperator operator,
5234 A arg) {
5235 apply(index, arg);
5236 return null;
5237 }
5238
5239 @override
5240 R visitUnresolvedSuperSetterIndexPostfix(
5241 Send node,
5242 MethodElement getter,
5243 Element element,
5244 Node index,
5245 IncDecOperator operator,
5246 A arg) {
5247 apply(index, arg);
5248 return null;
5249 }
5250
5251 @override
5252 R visitUnresolvedSuperIndexPostfix(
5253 Send node,
5254 Element element,
5255 Node index,
5256 IncDecOperator operator,
5257 A arg) {
5258 apply(index, arg);
5259 return null;
5260 }
5261
5262 @override
5263 R visitUnresolvedSuperGetterIndexPrefix(
5264 Send node,
5265 Element element,
5266 MethodElement setter,
5267 Node index,
5268 IncDecOperator operator,
5269 A arg) {
5270 apply(index, arg);
5271 return null;
5272 }
5273
5274 @override
5275 R visitUnresolvedSuperSetterIndexPrefix(
5276 Send node,
5277 MethodElement getter,
5278 Element element,
5279 Node index,
5280 IncDecOperator operator,
5281 A arg) {
5282 apply(index, arg);
5283 return null;
5284 }
5285
5286 @override
5287 R visitUnresolvedSuperIndexPrefix(
5288 Send node,
5289 Element element,
5290 Node index,
5291 IncDecOperator operator,
5292 A arg) {
5293 apply(index, arg);
5294 return null;
5295 }
5296
5297 @override
5298 R visitIndexPostfix(
5299 Send node,
5300 Node receiver,
5301 Node index,
5302 IncDecOperator operator,
5303 A arg) {
5304 apply(receiver, arg);
5305 apply(index, arg);
5306 return null;
5307 }
5308
5309 @override
5310 R visitIndexPrefix(
5311 Send node,
5312 Node receiver,
5313 Node index,
5314 IncDecOperator operator,
5315 A arg) {
5316 apply(receiver, arg);
5317 apply(index, arg);
5318 return null;
5319 }
5320
5321 @override
5322 R visitSuperIndexPostfix(
5323 Send node,
5324 FunctionElement indexFunction,
5325 FunctionElement indexSetFunction,
5326 Node index,
5327 IncDecOperator operator,
5328 A arg) {
5329 apply(index, arg);
5330 return null;
5331 }
5332
5333 @override
5334 R visitSuperIndexPrefix(
5335 Send node,
5336 FunctionElement indexFunction,
5337 FunctionElement indexSetFunction,
5338 Node index,
5339 IncDecOperator operator,
5340 A arg) {
5341 apply(index, arg);
5342 return null;
5343 }
5344
5345 @override
5346 R visitConstConstructorInvoke(
5347 NewExpression node,
5348 ConstructedConstantExpression constant,
5349 A arg) {
5350 return null;
5351 }
5352
5353 @override
5354 R visitUnresolvedClassConstructorInvoke(
5355 NewExpression node,
5356 Element constructor,
5357 DartType type,
5358 NodeList arguments,
5359 Selector selector,
5360 A arg) {
5361 apply(arguments, arg);
5362 return null;
5363 }
5364
5365 @override
5366 R visitUnresolvedConstructorInvoke(
5367 NewExpression node,
5368 Element constructor,
5369 DartType type,
5370 NodeList arguments,
5371 Selector selector,
5372 A arg) {
5373 apply(arguments, arg);
5374 return null;
5375 }
5376
5377 @override
5378 R visitFactoryConstructorInvoke(
5379 NewExpression node,
5380 ConstructorElement constructor,
5381 InterfaceType type,
5382 NodeList arguments,
5383 CallStructure callStructure,
5384 A arg) {
5385 apply(arguments, arg);
5386 return null;
5387 }
5388
5389 @override
5390 R visitGenerativeConstructorInvoke(
5391 NewExpression node,
5392 ConstructorElement constructor,
5393 InterfaceType type,
5394 NodeList arguments,
5395 CallStructure callStructure,
5396 A arg) {
5397 apply(arguments, arg);
5398 return null;
5399 }
5400
5401 @override
5402 R visitRedirectingFactoryConstructorInvoke(
5403 NewExpression node,
5404 ConstructorElement constructor,
5405 InterfaceType type,
5406 ConstructorElement effectiveTarget,
5407 InterfaceType effectiveTargetType,
5408 NodeList arguments,
5409 CallStructure callStructure,
5410 A arg) {
5411 apply(arguments, arg);
5412 return null;
5413 }
5414
5415 @override
5416 R visitRedirectingGenerativeConstructorInvoke(
5417 NewExpression node,
5418 ConstructorElement constructor,
5419 InterfaceType type,
5420 NodeList arguments,
5421 CallStructure callStructure,
5422 A arg) {
5423 apply(arguments, arg);
5424 return null;
5425 }
5426
5427 @override
5428 R visitAbstractClassConstructorInvoke(
5429 NewExpression node,
5430 ConstructorElement element,
5431 InterfaceType type,
5432 NodeList arguments,
5433 CallStructure callStructure,
5434 A arg) {
5435 apply(arguments, arg);
5436 return null;
5437 }
5438
5439 @override
5440 R visitUnresolvedRedirectingFactoryConstructorInvoke(
5441 NewExpression node,
5442 ConstructorElement constructor,
5443 InterfaceType type,
5444 NodeList arguments,
5445 CallStructure callStructure,
5446 A arg) {
5447 apply(arguments, arg);
5448 return null;
5449 }
5450
5451 @override
5452 R errorNonConstantConstructorInvoke(
5453 NewExpression node,
5454 Element element,
5455 DartType type,
5456 NodeList arguments,
5457 CallStructure callStructure,
5458 A arg) {
5459 apply(arguments, arg);
5460 return null;
5461 }
5462
5463 @override
5464 R visitUnresolvedStaticGetterCompound(
5465 Send node,
5466 Element element,
5467 MethodElement setter,
5468 AssignmentOperator operator,
5469 Node rhs,
5470 A arg) {
5471 apply(rhs, arg);
5472 return null;
5473 }
5474
5475 @override
5476 R visitUnresolvedTopLevelGetterCompound(
5477 Send node,
5478 Element element,
5479 MethodElement setter,
5480 AssignmentOperator operator,
5481 Node rhs,
5482 A arg) {
5483 apply(rhs, arg);
5484 return null;
5485 }
5486
5487 @override
5488 R visitUnresolvedStaticSetterCompound(
5489 Send node,
5490 MethodElement getter,
5491 Element element,
5492 AssignmentOperator operator,
5493 Node rhs,
5494 A arg) {
5495 apply(rhs, arg);
5496 return null;
5497 }
5498
5499 @override
5500 R visitUnresolvedTopLevelSetterCompound(
5501 Send node,
5502 MethodElement getter,
5503 Element element,
5504 AssignmentOperator operator,
5505 Node rhs,
5506 A arg) {
5507 apply(rhs, arg);
5508 return null;
5509 }
5510
5511 @override
5512 R visitStaticMethodCompound(
5513 Send node,
5514 MethodElement method,
5515 AssignmentOperator operator,
5516 Node rhs,
5517 A arg) {
5518 apply(rhs, arg);
5519 return null;
5520 }
5521
5522 @override
5523 R visitUnresolvedStaticGetterPrefix(
5524 Send node,
5525 Element element,
5526 MethodElement setter,
5527 IncDecOperator operator,
5528 A arg) {
5529 return null;
5530 }
5531
5532 @override
5533 R visitUnresolvedTopLevelGetterPrefix(
5534 Send node,
5535 Element element,
5536 MethodElement setter,
5537 IncDecOperator operator,
5538 A arg) {
5539 return null;
5540 }
5541
5542 @override
5543 R visitUnresolvedStaticSetterPrefix(
5544 Send node,
5545 MethodElement getter,
5546 Element element,
5547 IncDecOperator operator,
5548 A arg) {
5549 return null;
5550 }
5551
5552 @override
5553 R visitUnresolvedTopLevelSetterPrefix(
5554 Send node,
5555 MethodElement getter,
5556 Element element,
5557 IncDecOperator operator,
5558 A arg) {
5559 return null;
5560 }
5561
5562 @override
5563 R visitStaticMethodPrefix(
5564 Send node,
5565 MethodElement method,
5566 IncDecOperator operator,
5567 A arg) {
5568 return null;
5569 }
5570
5571 @override
5572 R visitTopLevelMethodPrefix(
5573 Send node,
5574 MethodElement method,
5575 IncDecOperator operator,
5576 A arg) {
5577 return null;
5578 }
5579
5580 @override
5581 R visitUnresolvedStaticGetterPostfix(
5582 Send node,
5583 Element element,
5584 MethodElement setter,
5585 IncDecOperator operator,
5586 A arg) {
5587 return null;
5588 }
5589
5590 @override
5591 R visitUnresolvedTopLevelGetterPostfix(
5592 Send node,
5593 Element element,
5594 MethodElement setter,
5595 IncDecOperator operator,
5596 A arg) {
5597 return null;
5598 }
5599
5600 @override
5601 R visitUnresolvedStaticSetterPostfix(
5602 Send node,
5603 MethodElement getter,
5604 Element element,
5605 IncDecOperator operator,
5606 A arg) {
5607 return null;
5608 }
5609
5610 @override
5611 R visitUnresolvedTopLevelSetterPostfix(
5612 Send node,
5613 MethodElement getter,
5614 Element element,
5615 IncDecOperator operator,
5616 A arg) {
5617 return null;
5618 }
5619
5620 @override
5621 R visitStaticMethodPostfix(
5622 Send node,
5623 MethodElement method,
5624 IncDecOperator operator,
5625 A arg) {
5626 return null;
5627 }
5628
5629 @override
5630 R visitTopLevelMethodPostfix(
5631 Send node,
5632 MethodElement method,
5633 IncDecOperator operator,
5634 A arg) {
5635 return null;
5636 }
5637
5638 @override
5639 R visitFinalLocalVariablePostfix(
5640 Send node,
5641 LocalVariableElement variable,
5642 IncDecOperator operator,
5643 A arg) {
5644 return null;
5645 }
5646
5647 @override
5648 R visitFinalLocalVariablePrefix(
5649 Send node,
5650 LocalVariableElement variable,
5651 IncDecOperator operator,
5652 A arg) {
5653 return null;
5654 }
5655
5656 @override
5657 R visitFinalParameterPostfix(
5658 Send node,
5659 ParameterElement parameter,
5660 IncDecOperator operator,
5661 A arg) {
5662 return null;
5663 }
5664
5665 @override
5666 R visitFinalParameterPrefix(
5667 Send node,
5668 ParameterElement parameter,
5669 IncDecOperator operator,
5670 A arg) {
5671 return null;
5672 }
5673
5674 @override
5675 R visitFinalStaticFieldPostfix(
5676 Send node,
5677 FieldElement field,
5678 IncDecOperator operator,
5679 A arg) {
5680 return null;
5681 }
5682
5683 @override
5684 R visitFinalStaticFieldPrefix(
5685 Send node,
5686 FieldElement field,
5687 IncDecOperator operator,
5688 A arg) {
5689 return null;
5690 }
5691
5692 @override
5693 R visitSuperFieldFieldCompound(
5694 Send node, FieldElement readField,
5695 FieldElement writtenField,
5696 AssignmentOperator operator,
5697 Node rhs,
5698 A arg) {
5699 apply(rhs, arg);
5700 return null;
5701 }
5702
5703 @override
5704 R visitFinalSuperFieldCompound(
5705 Send node,
5706 FieldElement field,
5707 AssignmentOperator operator,
5708 Node rhs,
5709 A arg) {
5710 apply(rhs, arg);
5711 return null;
5712 }
5713
5714 @override
5715 R visitFinalSuperFieldPostfix(
5716 Send node,
5717 FieldElement field,
5718 IncDecOperator operator,
5719 A arg) {
5720 return null;
5721 }
5722
5723 @override
5724 R visitFinalSuperFieldPrefix(
5725 Send node,
5726 FieldElement field,
5727 IncDecOperator operator,
5728 A arg) {
5729 return null;
5730 }
5731
5732 @override
5733 R visitSuperMethodCompound(
5734 Send node,
5735 FunctionElement method,
5736 AssignmentOperator operator,
5737 Node rhs,
5738 A arg) {
5739 apply(rhs, arg);
5740 return null;
5741 }
5742
5743 @override
5744 R visitSuperMethodPostfix(
5745 Send node,
5746 FunctionElement method,
5747 IncDecOperator operator,
5748 A arg) {
5749 return null;
5750 }
5751
5752 @override
5753 R visitSuperMethodPrefix(
5754 Send node,
5755 FunctionElement method,
5756 IncDecOperator operator,
5757 A arg) {
5758 return null;
5759 }
5760
5761 @override
5762 R visitFinalTopLevelFieldPostfix(
5763 Send node,
5764 FieldElement field,
5765 IncDecOperator operator,
5766 A arg) {
5767 return null;
5768 }
5769
5770 @override
5771 R visitFinalTopLevelFieldPrefix(
5772 Send node,
5773 FieldElement field,
5774 IncDecOperator operator,
5775 A arg) {
5776 return null;
5777 }
5778
5779 @override
5780 R visitTopLevelMethodCompound(
5781 Send node,
5782 FunctionElement method,
5783 AssignmentOperator operator,
5784 Node rhs,
5785 A arg) {
5786 apply(rhs, arg);
5787 return null;
5788 }
5789
5790 @override
5791 R visitUnresolvedSuperCompound(
5792 Send node,
5793 Element element,
5794 AssignmentOperator operator,
5795 Node rhs,
5796 A arg) {
5797 apply(rhs, arg);
5798 return null;
5799 }
5800
5801 @override
5802 R visitUnresolvedSuperPostfix(
5803 Send node,
5804 Element element,
5805 IncDecOperator operator,
5806 A arg) {
5807 return null;
5808 }
5809
5810 @override
5811 R visitUnresolvedSuperPrefix(
5812 Send node,
5813 Element element,
5814 IncDecOperator operator,
5815 A arg) {
5816 return null;
5817 }
5818
5819 @override
5820 R visitUnresolvedSuperGetterCompound(
5821 Send node, Element element,
5822 MethodElement setter,
5823 AssignmentOperator operator,
5824 Node rhs,
5825 A arg) {
5826 apply(rhs, arg);
5827 return null;
5828 }
5829
5830 @override
5831 R visitUnresolvedSuperGetterPostfix(
5832 Send node,
5833 Element element,
5834 MethodElement setter,
5835 IncDecOperator operator,
5836 A arg) {
5837 return null;
5838 }
5839
5840 @override
5841 R visitUnresolvedSuperGetterPrefix(
5842 Send node,
5843 Element element,
5844 MethodElement setter,
5845 IncDecOperator operator,
5846 A arg) {
5847 return null;
5848 }
5849
5850 @override
5851 R visitUnresolvedSuperSetterCompound(
5852 Send node, MethodElement getter,
5853 Element element,
5854 AssignmentOperator operator,
5855 Node rhs,
5856 A arg) {
5857 apply(rhs, arg);
5858 return null;
5859 }
5860
5861 @override
5862 R visitUnresolvedSuperSetterPostfix(
5863 Send node,
5864 MethodElement getter,
5865 Element element,
5866 IncDecOperator operator,
5867 A arg) {
5868 return null;
5869 }
5870
5871 @override
5872 R visitUnresolvedSuperSetterPrefix(
5873 Send node,
5874 MethodElement getter,
5875 Element element,
5876 IncDecOperator operator,
5877 A arg) {
5878 return null;
5879 }
5880 }
5881
5882 /// [SemanticDeclarationVisitor] that visits subnodes.
5883 class TraversalDeclarationMixin<R, A>
5884 implements SemanticDeclarationVisitor<R, A> {
5885 @override
5886 R apply(Node node, A arg) {
5887 throw new UnimplementedError("TraversalMixin.apply unimplemented");
5888 }
5889
5890 @override
5891 applyInitializers(NodeList initializers, A arg) {
5892 throw new UnimplementedError(
5893 "TraversalMixin.applyInitializers unimplemented");
5894 }
5895
5896 @override
5897 applyParameters(NodeList parameters, A arg) {
5898 throw new UnimplementedError(
5899 "TraversalMixin.applyParameters unimplemented");
5900 }
5901
5902 @override
5903 R visitAbstractMethodDeclaration(
5904 FunctionExpression node,
5905 MethodElement method,
5906 NodeList parameters,
5907 A arg) {
5908 applyParameters(parameters, arg);
5909 return null;
5910 }
5911
5912 @override
5913 R visitClosureDeclaration(
5914 FunctionExpression node,
5915 LocalFunctionElement function,
5916 NodeList parameters,
5917 Node body,
5918 A arg) {
5919 applyParameters(parameters, arg);
5920 apply(body, arg);
5921 return null;
5922 }
5923
5924 @override
5925 R visitFactoryConstructorDeclaration(
5926 FunctionExpression node,
5927 ConstructorElement constructor,
5928 NodeList parameters,
5929 Node body,
5930 A arg) {
5931 applyParameters(parameters, arg);
5932 apply(body, arg);
5933 return null;
5934 }
5935
5936 @override
5937 R visitFieldInitializer(
5938 SendSet node,
5939 FieldElement field,
5940 Node initializer,
5941 A arg) {
5942 apply(initializer, arg);
5943 return null;
5944 }
5945
5946 @override
5947 R visitGenerativeConstructorDeclaration(
5948 FunctionExpression node,
5949 ConstructorElement constructor,
5950 NodeList parameters,
5951 NodeList initializers,
5952 Node body,
5953 A arg) {
5954 applyParameters(parameters, arg);
5955 applyInitializers(initializers, arg);
5956 apply(body, arg);
5957 return null;
5958 }
5959
5960 @override
5961 R visitInstanceMethodDeclaration(
5962 FunctionExpression node,
5963 MethodElement method,
5964 NodeList parameters,
5965 Node body,
5966 A arg) {
5967 applyParameters(parameters, arg);
5968 apply(body, arg);
5969 return null;
5970 }
5971
5972 @override
5973 R visitLocalFunctionDeclaration(
5974 FunctionExpression node,
5975 LocalFunctionElement function,
5976 NodeList parameters,
5977 Node body,
5978 A arg) {
5979 applyParameters(parameters, arg);
5980 apply(body, arg);
5981 return null;
5982 }
5983
5984 @override
5985 R visitRedirectingFactoryConstructorDeclaration(
5986 FunctionExpression node,
5987 ConstructorElement constructor,
5988 NodeList parameters,
5989 InterfaceType redirectionType,
5990 ConstructorElement redirectionTarget,
5991 A arg) {
5992 applyParameters(parameters, arg);
5993 return null;
5994 }
5995
5996 @override
5997 R visitRedirectingGenerativeConstructorDeclaration(
5998 FunctionExpression node,
5999 ConstructorElement constructor,
6000 NodeList parameters,
6001 NodeList initializers,
6002 A arg) {
6003 applyParameters(parameters, arg);
6004 applyInitializers(initializers, arg);
6005 return null;
6006 }
6007
6008 @override
6009 R visitStaticFunctionDeclaration(
6010 FunctionExpression node,
6011 MethodElement function,
6012 NodeList parameters,
6013 Node body,
6014 A arg) {
6015 applyParameters(parameters, arg);
6016 apply(body, arg);
6017 return null;
6018 }
6019
6020 @override
6021 R visitSuperConstructorInvoke(
6022 Send node,
6023 ConstructorElement superConstructor,
6024 InterfaceType type,
6025 NodeList arguments,
6026 Selector selector,
6027 A arg) {
6028 apply(arguments, arg);
6029 return null;
6030 }
6031
6032 @override
6033 R visitThisConstructorInvoke(
6034 Send node,
6035 ConstructorElement thisConstructor,
6036 NodeList arguments,
6037 Selector selector,
6038 A arg) {
6039 apply(arguments, arg);
6040 return null;
6041 }
6042
6043 @override
6044 R visitTopLevelFunctionDeclaration(
6045 FunctionExpression node,
6046 MethodElement function,
6047 NodeList parameters,
6048 Node body,
6049 A arg) {
6050 applyParameters(parameters, arg);
6051 apply(body, arg);
6052 return null;
6053 }
6054
6055 @override
6056 R errorUnresolvedFieldInitializer(
6057 SendSet node,
6058 Element element,
6059 Node initializer,
6060 A arg) {
6061 apply(initializer, arg);
6062 return null;
6063 }
6064
6065 @override
6066 R errorUnresolvedSuperConstructorInvoke(
6067 Send node,
6068 Element element,
6069 NodeList arguments,
6070 Selector selector,
6071 A arg) {
6072 apply(arguments, arg);
6073 return null;
6074 }
6075
6076 @override
6077 R errorUnresolvedThisConstructorInvoke( 5189 R errorUnresolvedThisConstructorInvoke(
6078 Send node, 5190 Send node,
6079 Element element, 5191 Element element,
6080 NodeList arguments, 5192 NodeList arguments,
6081 Selector selector, 5193 Selector selector,
6082 A arg) { 5194 A arg) {
6083 apply(arguments, arg); 5195 apply(arguments, arg);
6084 return null; 5196 return null;
6085 } 5197 }
6086 5198
(...skipping 257 matching lines...) Expand 10 before | Expand all | Expand 10 after
6344 throw new SpannableAssertionFailure(spannable, message); 5456 throw new SpannableAssertionFailure(spannable, message);
6345 } 5457 }
6346 5458
6347 @override 5459 @override
6348 R visitNode(Node node) { 5460 R visitNode(Node node) {
6349 node.visitChildren(this); 5461 node.visitChildren(this);
6350 return null; 5462 return null;
6351 } 5463 }
6352 } 5464 }
6353 5465
6354 /// Mixin that groups all non-compound `visitStaticX` and `visitTopLevelX` 5466 /// Mixin that groups all `visitStaticX` and `visitTopLevelX` method by
6355 /// method by delegating calls to `handleStaticX` methods. 5467 /// delegating calls to `handleStaticX` methods.
6356 /// 5468 ///
6357 /// This mixin is useful for the cases where both top level members and static 5469 /// This mixin is useful for the cases where both top level members and static
6358 /// class members are handled uniformly. 5470 /// class members are handled uniformly.
6359 abstract class BaseImplementationOfStaticsMixin<R, A> 5471 abstract class BaseImplementationOfStaticsMixin<R, A>
6360 implements SemanticSendVisitor<R, A> { 5472 implements SemanticSendVisitor<R, A> {
5473 R handleStaticFieldCompound(
5474 Send node,
5475 FieldElement field,
5476 AssignmentOperator operator,
5477 Node rhs,
5478 A arg);
5479
6361 R handleStaticFieldGet( 5480 R handleStaticFieldGet(
6362 Send node, 5481 Send node,
6363 FieldElement field, 5482 FieldElement field,
6364 A arg); 5483 A arg);
6365 5484
6366 R handleStaticFieldInvoke( 5485 R handleStaticFieldInvoke(
6367 Send node, 5486 Send node,
6368 FieldElement field, 5487 FieldElement field,
6369 NodeList arguments, 5488 NodeList arguments,
6370 CallStructure callStructure, 5489 CallStructure callStructure,
6371 A arg); 5490 A arg);
6372 5491
5492 R handleStaticFieldPostfixPrefix(
5493 Send node,
5494 FieldElement field,
5495 IncDecOperator operator,
5496 A arg,
5497 {bool isPrefix});
5498
6373 R handleStaticFieldSet( 5499 R handleStaticFieldSet(
6374 SendSet node, 5500 SendSet node,
6375 FieldElement field, 5501 FieldElement field,
6376 Node rhs, 5502 Node rhs,
6377 A arg); 5503 A arg);
6378 5504
6379 R handleStaticFunctionGet( 5505 R handleStaticFunctionGet(
6380 Send node, 5506 Send node,
6381 MethodElement function, 5507 MethodElement function,
6382 A arg); 5508 A arg);
(...skipping 17 matching lines...) Expand all
6400 FunctionElement getter, 5526 FunctionElement getter,
6401 A arg); 5527 A arg);
6402 5528
6403 R handleStaticGetterInvoke( 5529 R handleStaticGetterInvoke(
6404 Send node, 5530 Send node,
6405 FunctionElement getter, 5531 FunctionElement getter,
6406 NodeList arguments, 5532 NodeList arguments,
6407 CallStructure callStructure, 5533 CallStructure callStructure,
6408 A arg); 5534 A arg);
6409 5535
5536 R handleStaticGetterSetterCompound(
5537 Send node,
5538 FunctionElement getter,
5539 FunctionElement setter,
5540 AssignmentOperator operator,
5541 Node rhs,
5542 A arg);
5543
5544 R handleStaticGetterSetterPostfixPrefix(
5545 Send node,
5546 FunctionElement getter,
5547 FunctionElement setter,
5548 IncDecOperator operator,
5549 A arg,
5550 {bool isPrefix});
5551
5552 R handleStaticMethodSetterCompound(
5553 Send node,
5554 FunctionElement method,
5555 FunctionElement setter,
5556 AssignmentOperator operator,
5557 Node rhs,
5558 A arg);
5559
5560 R handleStaticMethodSetterPostfixPrefix(
5561 Send node,
5562 FunctionElement getter,
5563 FunctionElement setter,
5564 IncDecOperator operator,
5565 A arg,
5566 {bool isPrefix});
5567
6410 R handleStaticSetterSet( 5568 R handleStaticSetterSet(
6411 SendSet node, 5569 SendSet node,
6412 FunctionElement setter, 5570 FunctionElement setter,
6413 Node rhs, 5571 Node rhs,
6414 A arg); 5572 A arg);
6415 5573
6416 @override 5574 @override
5575 R visitStaticFieldCompound(
5576 Send node,
5577 FieldElement field,
5578 AssignmentOperator operator,
5579 Node rhs,
5580 A arg) {
5581 return handleStaticFieldCompound(node, field, operator, rhs, arg);
5582 }
5583
5584 @override
6417 R visitStaticFieldGet( 5585 R visitStaticFieldGet(
6418 Send node, 5586 Send node,
6419 FieldElement field, 5587 FieldElement field,
6420 A arg) { 5588 A arg) {
6421 return handleStaticFieldGet(node, field, arg); 5589 return handleStaticFieldGet(node, field, arg);
6422 } 5590 }
6423 5591
6424 @override 5592 @override
6425 R visitStaticFieldInvoke( 5593 R visitStaticFieldInvoke(
6426 Send node, 5594 Send node,
6427 FieldElement field, 5595 FieldElement field,
6428 NodeList arguments, 5596 NodeList arguments,
6429 CallStructure callStructure, 5597 CallStructure callStructure,
6430 A arg) { 5598 A arg) {
6431 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg); 5599 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
6432 } 5600 }
6433 5601
6434 @override 5602 @override
5603 R visitStaticFieldPostfix(
5604 Send node,
5605 FieldElement field,
5606 IncDecOperator operator,
5607 A arg) {
5608 return handleStaticFieldPostfixPrefix(
5609 node, field, operator, arg, isPrefix: false);
5610 }
5611
5612 @override
5613 R visitStaticFieldPrefix(
5614 Send node,
5615 FieldElement field,
5616 IncDecOperator operator,
5617 A arg) {
5618 return handleStaticFieldPostfixPrefix(
5619 node, field, operator, arg, isPrefix: true);
5620 }
5621
5622 @override
6435 R visitStaticFieldSet( 5623 R visitStaticFieldSet(
6436 SendSet node, 5624 SendSet node,
6437 FieldElement field, 5625 FieldElement field,
6438 Node rhs, 5626 Node rhs,
6439 A arg) { 5627 A arg) {
6440 return handleStaticFieldSet(node, field, rhs, arg); 5628 return handleStaticFieldSet(node, field, rhs, arg);
6441 } 5629 }
6442 5630
6443 @override 5631 @override
6444 R visitStaticFunctionGet( 5632 R visitStaticFunctionGet(
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
6483 Send node, 5671 Send node,
6484 FunctionElement getter, 5672 FunctionElement getter,
6485 NodeList arguments, 5673 NodeList arguments,
6486 CallStructure callStructure, 5674 CallStructure callStructure,
6487 A arg) { 5675 A arg) {
6488 return handleStaticGetterInvoke( 5676 return handleStaticGetterInvoke(
6489 node, getter, arguments, callStructure, arg); 5677 node, getter, arguments, callStructure, arg);
6490 } 5678 }
6491 5679
6492 @override 5680 @override
5681 R visitStaticGetterSetterCompound(
5682 Send node,
5683 FunctionElement getter,
5684 FunctionElement setter,
5685 AssignmentOperator operator,
5686 Node rhs,
5687 A arg) {
5688 return handleStaticGetterSetterCompound(
5689 node, getter, setter, operator, rhs, arg);
5690 }
5691
5692 @override
5693 R visitStaticGetterSetterPostfix(
5694 Send node,
5695 FunctionElement getter,
5696 FunctionElement setter,
5697 IncDecOperator operator,
5698 A arg) {
5699 return handleStaticGetterSetterPostfixPrefix(
5700 node, getter, setter, operator, arg, isPrefix: false);
5701 }
5702
5703 @override
5704 R visitStaticGetterSetterPrefix(
5705 Send node,
5706 FunctionElement getter,
5707 FunctionElement setter,
5708 IncDecOperator operator,
5709 A arg) {
5710 return handleStaticGetterSetterPostfixPrefix(
5711 node, getter, setter, operator, arg, isPrefix: true);
5712 }
5713
5714 @override
5715 R visitStaticMethodSetterCompound(
5716 Send node,
5717 FunctionElement method,
5718 FunctionElement setter,
5719 AssignmentOperator operator,
5720 Node rhs,
5721 A arg) {
5722 return handleStaticMethodSetterCompound(
5723 node, method, setter, operator, rhs, arg);
5724 }
5725
5726 @override
5727 R visitStaticMethodSetterPostfix(
5728 Send node,
5729 FunctionElement getter,
5730 FunctionElement setter,
5731 IncDecOperator operator,
5732 A arg) {
5733 return handleStaticMethodSetterPostfixPrefix(
5734 node, getter, setter, operator, arg, isPrefix: false);
5735 }
5736
5737 @override
5738 R visitStaticMethodSetterPrefix(
5739 Send node,
5740 FunctionElement getter,
5741 FunctionElement setter,
5742 IncDecOperator operator,
5743 A arg) {
5744 return handleStaticMethodSetterPostfixPrefix(
5745 node, getter, setter, operator, arg, isPrefix: true);
5746 }
5747
5748 @override
6493 R visitStaticSetterSet( 5749 R visitStaticSetterSet(
6494 SendSet node, 5750 SendSet node,
6495 FunctionElement setter, 5751 FunctionElement setter,
6496 Node rhs, 5752 Node rhs,
6497 A arg) { 5753 A arg) {
6498 return handleStaticSetterSet(node, setter, rhs, arg); 5754 return handleStaticSetterSet(node, setter, rhs, arg);
6499 } 5755 }
6500 5756
6501 @override 5757 @override
5758 R visitTopLevelFieldCompound(
5759 Send node,
5760 FieldElement field,
5761 AssignmentOperator operator,
5762 Node rhs,
5763 A arg) {
5764 return handleStaticFieldCompound(node, field, operator, rhs, arg);
5765 }
5766
5767 @override
6502 R visitTopLevelFieldGet( 5768 R visitTopLevelFieldGet(
6503 Send node, 5769 Send node,
6504 FieldElement field, 5770 FieldElement field,
6505 A arg) { 5771 A arg) {
6506 return handleStaticFieldGet(node, field, arg); 5772 return handleStaticFieldGet(node, field, arg);
6507 } 5773 }
6508 5774
6509 @override 5775 @override
6510 R visitTopLevelFieldInvoke( 5776 R visitTopLevelFieldInvoke(
6511 Send node, 5777 Send node,
6512 FieldElement field, 5778 FieldElement field,
6513 NodeList arguments, 5779 NodeList arguments,
6514 CallStructure callStructure, 5780 CallStructure callStructure,
6515 A arg) { 5781 A arg) {
6516 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg); 5782 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
6517 } 5783 }
6518 5784
6519 @override 5785 @override
5786 R visitTopLevelFieldPostfix(
5787 Send node,
5788 FieldElement field,
5789 IncDecOperator operator,
5790 A arg) {
5791 return handleStaticFieldPostfixPrefix(
5792 node, field, operator, arg, isPrefix: false);
5793 }
5794
5795 @override
5796 R visitTopLevelFieldPrefix(
5797 Send node,
5798 FieldElement field,
5799 IncDecOperator operator,
5800 A arg) {
5801 return handleStaticFieldPostfixPrefix(
5802 node, field, operator, arg, isPrefix: true);
5803 }
5804
5805 @override
6520 R visitTopLevelFieldSet( 5806 R visitTopLevelFieldSet(
6521 SendSet node, 5807 SendSet node,
6522 FieldElement field, 5808 FieldElement field,
6523 Node rhs, 5809 Node rhs,
6524 A arg) { 5810 A arg) {
6525 return handleStaticFieldSet(node, field, rhs, arg); 5811 return handleStaticFieldSet(node, field, rhs, arg);
6526 } 5812 }
6527 5813
6528 @override 5814 @override
6529 R visitTopLevelFunctionGet( 5815 R visitTopLevelFunctionGet(
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
6568 Send node, 5854 Send node,
6569 FunctionElement getter, 5855 FunctionElement getter,
6570 NodeList arguments, 5856 NodeList arguments,
6571 CallStructure callStructure, 5857 CallStructure callStructure,
6572 A arg) { 5858 A arg) {
6573 return handleStaticGetterInvoke( 5859 return handleStaticGetterInvoke(
6574 node, getter, arguments, callStructure, arg); 5860 node, getter, arguments, callStructure, arg);
6575 } 5861 }
6576 5862
6577 @override 5863 @override
5864 R visitTopLevelGetterSetterCompound(
5865 Send node,
5866 FunctionElement getter,
5867 FunctionElement setter,
5868 AssignmentOperator operator,
5869 Node rhs,
5870 A arg) {
5871 return handleStaticGetterSetterCompound(
5872 node, getter, setter, operator, rhs, arg);
5873 }
5874
5875 @override
5876 R visitTopLevelGetterSetterPostfix(
5877 Send node,
5878 FunctionElement getter,
5879 FunctionElement setter,
5880 IncDecOperator operator,
5881 A arg) {
5882 return handleStaticGetterSetterPostfixPrefix(
5883 node, getter, setter, operator, arg, isPrefix: false);
5884 }
5885
5886 @override
5887 R visitTopLevelGetterSetterPrefix(
5888 Send node,
5889 FunctionElement getter,
5890 FunctionElement setter,
5891 IncDecOperator operator,
5892 A arg) {
5893 return handleStaticGetterSetterPostfixPrefix(
5894 node, getter, setter, operator, arg, isPrefix: true);
5895 }
5896
5897 @override
5898 R visitTopLevelMethodSetterCompound(
5899 Send node,
5900 FunctionElement method,
5901 FunctionElement setter,
5902 AssignmentOperator operator,
5903 Node rhs,
5904 A arg) {
5905 return handleStaticMethodSetterCompound(
5906 node, method, setter, operator, rhs, arg);
5907 }
5908
5909 @override
5910 R visitTopLevelMethodSetterPostfix(
5911 Send node,
5912 FunctionElement method,
5913 FunctionElement setter,
5914 IncDecOperator operator,
5915 A arg) {
5916 return handleStaticMethodSetterPostfixPrefix(
5917 node, method, setter, operator, arg, isPrefix: false);
5918 }
5919
5920 @override
5921 R visitTopLevelMethodSetterPrefix(
5922 Send node,
5923 FunctionElement method,
5924 FunctionElement setter,
5925 IncDecOperator operator,
5926 A arg) {
5927 return handleStaticMethodSetterPostfixPrefix(
5928 node, method, setter, operator, arg, isPrefix: true);
5929 }
5930
5931 @override
6578 R visitTopLevelSetterSet( 5932 R visitTopLevelSetterSet(
6579 SendSet node, 5933 SendSet node,
6580 FunctionElement setter, 5934 FunctionElement setter,
6581 Node rhs, 5935 Node rhs,
6582 A arg) { 5936 A arg) {
6583 return handleStaticSetterSet(node, setter, rhs, arg); 5937 return handleStaticSetterSet(node, setter, rhs, arg);
6584 } 5938 }
6585 } 5939 }
6586 5940
6587 /// Mixin that groups all compounds visitors `visitStaticX` and `visitTopLevelX` 5941 /// Mixin that groups all `visitLocalX` and `visitParameterX` method by
6588 /// method by delegating calls to `handleStaticX` methods. 5942 /// delegating calls to `handleLocalX` methods.
6589 ///
6590 /// This mixin is useful for the cases where both top level members and static
6591 /// class members are handled uniformly.
6592 abstract class BaseImplementationOfStaticCompoundsMixin<R, A>
6593 implements SemanticSendVisitor<R, A> {
6594 R handleStaticFieldCompound(
6595 Send node,
6596 FieldElement field,
6597 AssignmentOperator operator,
6598 Node rhs,
6599 A arg);
6600
6601 R handleStaticFieldPostfixPrefix(
6602 Send node,
6603 FieldElement field,
6604 IncDecOperator operator,
6605 A arg,
6606 {bool isPrefix});
6607
6608 R handleStaticGetterSetterCompound(
6609 Send node,
6610 FunctionElement getter,
6611 FunctionElement setter,
6612 AssignmentOperator operator,
6613 Node rhs,
6614 A arg);
6615
6616 R handleStaticGetterSetterPostfixPrefix(
6617 Send node,
6618 FunctionElement getter,
6619 FunctionElement setter,
6620 IncDecOperator operator,
6621 A arg,
6622 {bool isPrefix});
6623
6624 R handleStaticMethodSetterCompound(
6625 Send node,
6626 FunctionElement method,
6627 FunctionElement setter,
6628 AssignmentOperator operator,
6629 Node rhs,
6630 A arg);
6631
6632 R handleStaticMethodSetterPostfixPrefix(
6633 Send node,
6634 FunctionElement getter,
6635 FunctionElement setter,
6636 IncDecOperator operator,
6637 A arg,
6638 {bool isPrefix});
6639
6640 R handleFinalStaticFieldCompound(
6641 Send node,
6642 FieldElement field,
6643 AssignmentOperator operator,
6644 Node rhs,
6645 A arg);
6646
6647 R handleFinalStaticFieldPostfixPrefix(
6648 Send node,
6649 FieldElement field,
6650 IncDecOperator operator,
6651 A arg,
6652 {bool isPrefix});
6653
6654 R handleStaticMethodCompound(
6655 Send node,
6656 FunctionElement method,
6657 AssignmentOperator operator,
6658 Node rhs,
6659 A arg);
6660
6661 R handleStaticMethodPostfixPrefix(
6662 Send node,
6663 FunctionElement method,
6664 IncDecOperator operator,
6665 A arg,
6666 {bool isPrefix});
6667
6668 R handleUnresolvedStaticGetterCompound(
6669 Send node,
6670 Element element,
6671 FunctionElement setter,
6672 AssignmentOperator operator,
6673 Node rhs,
6674 A arg);
6675
6676 R handleUnresolvedStaticGetterPostfixPrefix(
6677 Send node,
6678 Element element,
6679 FunctionElement setter,
6680 IncDecOperator operator,
6681 A arg,
6682 {bool isPrefix});
6683
6684 R handleUnresolvedStaticSetterCompound(
6685 Send node,
6686 FunctionElement getter,
6687 Element element,
6688 AssignmentOperator operator,
6689 Node rhs,
6690 A arg);
6691
6692 R handleUnresolvedStaticSetterPostfixPrefix(
6693 Send node,
6694 FunctionElement getter,
6695 Element element,
6696 IncDecOperator operator,
6697 A arg,
6698 {bool isPrefix});
6699
6700 @override
6701 R visitStaticFieldCompound(
6702 Send node,
6703 FieldElement field,
6704 AssignmentOperator operator,
6705 Node rhs,
6706 A arg) {
6707 return handleStaticFieldCompound(node, field, operator, rhs, arg);
6708 }
6709
6710 @override
6711 R visitStaticFieldPostfix(
6712 Send node,
6713 FieldElement field,
6714 IncDecOperator operator,
6715 A arg) {
6716 return handleStaticFieldPostfixPrefix(
6717 node, field, operator, arg, isPrefix: false);
6718 }
6719
6720 @override
6721 R visitStaticFieldPrefix(
6722 Send node,
6723 FieldElement field,
6724 IncDecOperator operator,
6725 A arg) {
6726 return handleStaticFieldPostfixPrefix(
6727 node, field, operator, arg, isPrefix: true);
6728 }
6729
6730 @override
6731 R visitStaticGetterSetterCompound(
6732 Send node,
6733 FunctionElement getter,
6734 FunctionElement setter,
6735 AssignmentOperator operator,
6736 Node rhs,
6737 A arg) {
6738 return handleStaticGetterSetterCompound(
6739 node, getter, setter, operator, rhs, arg);
6740 }
6741
6742 @override
6743 R visitStaticGetterSetterPostfix(
6744 Send node,
6745 FunctionElement getter,
6746 FunctionElement setter,
6747 IncDecOperator operator,
6748 A arg) {
6749 return handleStaticGetterSetterPostfixPrefix(
6750 node, getter, setter, operator, arg, isPrefix: false);
6751 }
6752
6753 @override
6754 R visitStaticGetterSetterPrefix(
6755 Send node,
6756 FunctionElement getter,
6757 FunctionElement setter,
6758 IncDecOperator operator,
6759 A arg) {
6760 return handleStaticGetterSetterPostfixPrefix(
6761 node, getter, setter, operator, arg, isPrefix: true);
6762 }
6763
6764 @override
6765 R visitStaticMethodSetterCompound(
6766 Send node,
6767 FunctionElement method,
6768 FunctionElement setter,
6769 AssignmentOperator operator,
6770 Node rhs,
6771 A arg) {
6772 return handleStaticMethodSetterCompound(
6773 node, method, setter, operator, rhs, arg);
6774 }
6775
6776 @override
6777 R visitStaticMethodSetterPostfix(
6778 Send node,
6779 FunctionElement getter,
6780 FunctionElement setter,
6781 IncDecOperator operator,
6782 A arg) {
6783 return handleStaticMethodSetterPostfixPrefix(
6784 node, getter, setter, operator, arg, isPrefix: false);
6785 }
6786
6787 @override
6788 R visitStaticMethodSetterPrefix(
6789 Send node,
6790 FunctionElement getter,
6791 FunctionElement setter,
6792 IncDecOperator operator,
6793 A arg) {
6794 return handleStaticMethodSetterPostfixPrefix(
6795 node, getter, setter, operator, arg, isPrefix: true);
6796 }
6797
6798 @override
6799 R visitTopLevelFieldCompound(
6800 Send node,
6801 FieldElement field,
6802 AssignmentOperator operator,
6803 Node rhs,
6804 A arg) {
6805 return handleStaticFieldCompound(node, field, operator, rhs, arg);
6806 }
6807
6808 @override
6809 R visitTopLevelFieldPostfix(
6810 Send node,
6811 FieldElement field,
6812 IncDecOperator operator,
6813 A arg) {
6814 return handleStaticFieldPostfixPrefix(
6815 node, field, operator, arg, isPrefix: false);
6816 }
6817
6818 @override
6819 R visitTopLevelFieldPrefix(
6820 Send node,
6821 FieldElement field,
6822 IncDecOperator operator,
6823 A arg) {
6824 return handleStaticFieldPostfixPrefix(
6825 node, field, operator, arg, isPrefix: true);
6826 }
6827
6828 @override
6829 R visitTopLevelGetterSetterCompound(
6830 Send node,
6831 FunctionElement getter,
6832 FunctionElement setter,
6833 AssignmentOperator operator,
6834 Node rhs,
6835 A arg) {
6836 return handleStaticGetterSetterCompound(
6837 node, getter, setter, operator, rhs, arg);
6838 }
6839
6840 @override
6841 R visitTopLevelGetterSetterPostfix(
6842 Send node,
6843 FunctionElement getter,
6844 FunctionElement setter,
6845 IncDecOperator operator,
6846 A arg) {
6847 return handleStaticGetterSetterPostfixPrefix(
6848 node, getter, setter, operator, arg, isPrefix: false);
6849 }
6850
6851 @override
6852 R visitTopLevelGetterSetterPrefix(
6853 Send node,
6854 FunctionElement getter,
6855 FunctionElement setter,
6856 IncDecOperator operator,
6857 A arg) {
6858 return handleStaticGetterSetterPostfixPrefix(
6859 node, getter, setter, operator, arg, isPrefix: true);
6860 }
6861
6862 @override
6863 R visitTopLevelMethodSetterCompound(
6864 Send node,
6865 FunctionElement method,
6866 FunctionElement setter,
6867 AssignmentOperator operator,
6868 Node rhs,
6869 A arg) {
6870 return handleStaticMethodSetterCompound(
6871 node, method, setter, operator, rhs, arg);
6872 }
6873
6874 @override
6875 R visitTopLevelMethodSetterPostfix(
6876 Send node,
6877 FunctionElement method,
6878 FunctionElement setter,
6879 IncDecOperator operator,
6880 A arg) {
6881 return handleStaticMethodSetterPostfixPrefix(
6882 node, method, setter, operator, arg, isPrefix: false);
6883 }
6884
6885 @override
6886 R visitTopLevelMethodSetterPrefix(
6887 Send node,
6888 FunctionElement method,
6889 FunctionElement setter,
6890 IncDecOperator operator,
6891 A arg) {
6892 return handleStaticMethodSetterPostfixPrefix(
6893 node, method, setter, operator, arg, isPrefix: true);
6894 }
6895
6896 @override
6897 R visitFinalStaticFieldCompound(
6898 Send node,
6899 FieldElement field,
6900 AssignmentOperator operator,
6901 Node rhs,
6902 A arg) {
6903 return handleFinalStaticFieldCompound(
6904 node, field, operator, rhs, arg);
6905 }
6906
6907 @override
6908 R visitFinalStaticFieldPostfix(
6909 Send node,
6910 FieldElement field,
6911 IncDecOperator operator,
6912 A arg) {
6913 return handleFinalStaticFieldPostfixPrefix(
6914 node, field, operator, arg, isPrefix: false);
6915 }
6916
6917 @override
6918 R visitFinalStaticFieldPrefix(
6919 Send node,
6920 FieldElement field,
6921 IncDecOperator operator,
6922 A arg) {
6923 return handleFinalStaticFieldPostfixPrefix(
6924 node, field, operator, arg, isPrefix: true);
6925 }
6926
6927 @override
6928 R visitStaticMethodCompound(
6929 Send node,
6930 FunctionElement method,
6931 AssignmentOperator operator,
6932 Node rhs,
6933 A arg) {
6934 return handleStaticMethodCompound(
6935 node, method, operator, rhs, arg);
6936 }
6937
6938 @override
6939 R visitStaticMethodPostfix(
6940 Send node,
6941 FunctionElement method,
6942 IncDecOperator operator,
6943 A arg) {
6944 return handleStaticMethodPostfixPrefix(
6945 node, method, operator, arg, isPrefix: false);
6946 }
6947
6948 @override
6949 R visitStaticMethodPrefix(
6950 Send node,
6951 FunctionElement method,
6952 IncDecOperator operator,
6953 A arg) {
6954 return handleStaticMethodPostfixPrefix(
6955 node, method, operator, arg, isPrefix: true);
6956 }
6957
6958 @override
6959 R visitUnresolvedStaticGetterCompound(
6960 Send node,
6961 Element element,
6962 FunctionElement setter,
6963 AssignmentOperator operator,
6964 Node rhs,
6965 A arg) {
6966 return handleUnresolvedStaticGetterCompound(
6967 node, element, setter, operator, rhs, arg);
6968 }
6969
6970 @override
6971 R visitUnresolvedStaticGetterPostfix(
6972 Send node,
6973 Element element,
6974 FunctionElement setter,
6975 IncDecOperator operator,
6976 A arg) {
6977 return handleUnresolvedStaticGetterPostfixPrefix(
6978 node, element, setter, operator, arg, isPrefix: false);
6979 }
6980
6981 @override
6982 R visitUnresolvedStaticGetterPrefix(
6983 Send node,
6984 Element element,
6985 FunctionElement setter,
6986 IncDecOperator operator,
6987 A arg) {
6988 return handleUnresolvedStaticGetterPostfixPrefix(
6989 node, element, setter, operator, arg, isPrefix: true);
6990 }
6991
6992 @override
6993 R visitUnresolvedStaticSetterCompound(
6994 Send node,
6995 FunctionElement getter,
6996 Element element,
6997 AssignmentOperator operator,
6998 Node rhs,
6999 A arg) {
7000 return handleUnresolvedStaticSetterCompound(
7001 node, getter, element, operator, rhs, arg);
7002 }
7003
7004 @override
7005 R visitUnresolvedStaticSetterPostfix(
7006 Send node,
7007 FunctionElement getter,
7008 Element element,
7009 IncDecOperator operator,
7010 A arg) {
7011 return handleUnresolvedStaticSetterPostfixPrefix(
7012 node, getter, element, operator, arg, isPrefix: false);
7013 }
7014
7015 @override
7016 R visitUnresolvedStaticSetterPrefix(
7017 Send node,
7018 FunctionElement getter,
7019 Element element,
7020 IncDecOperator operator,
7021 A arg) {
7022 return handleUnresolvedStaticSetterPostfixPrefix(
7023 node, getter, element, operator, arg, isPrefix: true);
7024 }
7025 }
7026
7027 /// Mixin that groups all non-compound `visitLocalX` and `visitParameterX`
7028 /// methods by delegating calls to `handleLocalX` methods.
7029 /// 5943 ///
7030 /// This mixin is useful for the cases where both parameters, local variables, 5944 /// This mixin is useful for the cases where both parameters, local variables,
7031 /// and local functions, captured or not, are handled uniformly. 5945 /// and local functions, captured or not, are handled uniformly.
7032 abstract class BaseImplementationOfLocalsMixin<R, A> 5946 abstract class BaseImplementationOfLocalsMixin<R, A>
7033 implements SemanticSendVisitor<R, A> { 5947 implements SemanticSendVisitor<R, A> {
5948 R handleLocalCompound(
5949 Send node,
5950 LocalElement element,
5951 AssignmentOperator operator,
5952 Node rhs,
5953 A arg);
5954
7034 R handleLocalGet( 5955 R handleLocalGet(
7035 Send node, 5956 Send node,
7036 LocalElement element, 5957 LocalElement element,
7037 A arg); 5958 A arg);
7038 5959
7039 R handleLocalInvoke( 5960 R handleLocalInvoke(
7040 Send node, 5961 Send node,
7041 LocalElement element, 5962 LocalElement element,
7042 NodeList arguments, 5963 NodeList arguments,
7043 CallStructure callStructure, 5964 CallStructure callStructure,
7044 A arg); 5965 A arg);
7045 5966
5967 R handleLocalPostfixPrefix(
5968 Send node,
5969 LocalElement element,
5970 IncDecOperator operator,
5971 A arg,
5972 {bool isPrefix});
5973
7046 R handleLocalSet( 5974 R handleLocalSet(
7047 SendSet node, 5975 SendSet node,
7048 LocalElement element, 5976 LocalElement element,
7049 Node rhs, 5977 Node rhs,
7050 A arg); 5978 A arg);
7051 5979
7052 @override 5980 @override
7053 R visitLocalFunctionGet( 5981 R visitLocalFunctionGet(
7054 Send node, 5982 Send node,
7055 LocalFunctionElement function, 5983 LocalFunctionElement function,
7056 A arg) { 5984 A arg) {
7057 return handleLocalGet(node, function, arg); 5985 return handleLocalGet(node, function, arg);
7058 } 5986 }
7059 5987
7060 @override 5988 @override
7061 R visitLocalFunctionInvoke( 5989 R visitLocalFunctionInvoke(
7062 Send node, 5990 Send node,
7063 LocalFunctionElement function, 5991 LocalFunctionElement function,
7064 NodeList arguments, 5992 NodeList arguments,
7065 CallStructure callStructure, 5993 CallStructure callStructure,
7066 A arg) { 5994 A arg) {
7067 return handleLocalInvoke(node, function, arguments, callStructure, arg); 5995 return handleLocalInvoke(node, function, arguments, callStructure, arg);
7068 } 5996 }
7069 5997
7070 @override 5998 @override
5999 R visitLocalVariableCompound(
6000 Send node,
6001 LocalVariableElement variable,
6002 AssignmentOperator operator,
6003 Node rhs,
6004 A arg) {
6005 return handleLocalCompound(node, variable, operator, rhs, arg);
6006 }
6007
6008 @override
7071 R visitLocalVariableGet( 6009 R visitLocalVariableGet(
7072 Send node, 6010 Send node,
7073 LocalVariableElement variable, 6011 LocalVariableElement variable,
7074 A arg) { 6012 A arg) {
7075 return handleLocalGet(node, variable, arg); 6013 return handleLocalGet(node, variable, arg);
7076 } 6014 }
7077 6015
7078 @override 6016 @override
7079 R visitLocalVariableInvoke( 6017 R visitLocalVariableInvoke(
7080 Send node, 6018 Send node,
7081 LocalVariableElement variable, 6019 LocalVariableElement variable,
7082 NodeList arguments, 6020 NodeList arguments,
7083 CallStructure callStructure, 6021 CallStructure callStructure,
7084 A arg) { 6022 A arg) {
7085 return handleLocalInvoke(node, variable, arguments, callStructure, arg); 6023 return handleLocalInvoke(node, variable, arguments, callStructure, arg);
7086 } 6024 }
7087 6025
7088 @override 6026 @override
6027 R visitLocalVariablePostfix(
6028 Send node,
6029 LocalVariableElement variable,
6030 IncDecOperator operator,
6031 A arg) {
6032 return handleLocalPostfixPrefix(
6033 node, variable, operator, arg, isPrefix: false);
6034 }
6035
6036 @override
6037 R visitLocalVariablePrefix(
6038 Send node,
6039 LocalVariableElement variable,
6040 IncDecOperator operator,
6041 A arg) {
6042 return handleLocalPostfixPrefix(
6043 node, variable, operator, arg, isPrefix: true);
6044 }
6045
6046 @override
7089 R visitLocalVariableSet( 6047 R visitLocalVariableSet(
7090 SendSet node, 6048 SendSet node,
7091 LocalVariableElement variable, 6049 LocalVariableElement variable,
7092 Node rhs, 6050 Node rhs,
7093 A arg) { 6051 A arg) {
7094 return handleLocalSet(node, variable, rhs, arg); 6052 return handleLocalSet(node, variable, rhs, arg);
7095 } 6053 }
7096 6054
7097 @override 6055 @override
6056 R visitParameterCompound(
6057 Send node,
6058 ParameterElement parameter,
6059 AssignmentOperator operator,
6060 Node rhs,
6061 A arg) {
6062 return handleLocalCompound(node, parameter, operator, rhs, arg);
6063 }
6064
6065 @override
7098 R visitParameterGet( 6066 R visitParameterGet(
7099 Send node, 6067 Send node,
7100 ParameterElement parameter, 6068 ParameterElement parameter,
7101 A arg) { 6069 A arg) {
7102 return handleLocalGet(node, parameter, arg); 6070 return handleLocalGet(node, parameter, arg);
7103 } 6071 }
7104 6072
7105 @override 6073 @override
7106 R visitParameterInvoke( 6074 R visitParameterInvoke(
7107 Send node, 6075 Send node,
7108 ParameterElement parameter, 6076 ParameterElement parameter,
7109 NodeList arguments, 6077 NodeList arguments,
7110 CallStructure callStructure, 6078 CallStructure callStructure,
7111 A arg) { 6079 A arg) {
7112 return handleLocalInvoke(node, parameter, arguments, callStructure, arg); 6080 return handleLocalInvoke(node, parameter, arguments, callStructure, arg);
7113 } 6081 }
7114 6082
7115 @override 6083 @override
6084 R visitParameterPostfix(
6085 Send node,
6086 ParameterElement parameter,
6087 IncDecOperator operator,
6088 A arg) {
6089 return handleLocalPostfixPrefix(
6090 node, parameter, operator, arg, isPrefix: false);
6091 }
6092
6093 @override
6094 R visitParameterPrefix(
6095 Send node,
6096 ParameterElement parameter,
6097 IncDecOperator operator,
6098 A arg) {
6099 return handleLocalPostfixPrefix(
6100 node, parameter, operator, arg, isPrefix: true);
6101 }
6102
6103 @override
7116 R visitParameterSet( 6104 R visitParameterSet(
7117 SendSet node, 6105 SendSet node,
7118 ParameterElement parameter, 6106 ParameterElement parameter,
7119 Node rhs, 6107 Node rhs,
7120 A arg) { 6108 A arg) {
7121 return handleLocalSet(node, parameter, rhs, arg); 6109 return handleLocalSet(node, parameter, rhs, arg);
7122 } 6110 }
7123 } 6111 }
7124 6112
7125 /// Mixin that groups all compound `visitLocalX` and `visitParameterX` methods
7126 /// by delegating calls to `handleLocalX` methods.
7127 ///
7128 /// This mixin is useful for the cases where both parameters, local variables,
7129 /// and local functions, captured or not, are handled uniformly.
7130 abstract class BaseImplementationOfLocalCompoundsMixin<R, A>
7131 implements SemanticSendVisitor<R, A> {
7132 R handleLocalCompound(
7133 Send node,
7134 LocalElement element,
7135 AssignmentOperator operator,
7136 Node rhs,
7137 A arg);
7138
7139 R handleLocalPostfixPrefix(
7140 Send node,
7141 LocalElement element,
7142 IncDecOperator operator,
7143 A arg,
7144 {bool isPrefix});
7145
7146 @override
7147 R visitLocalVariableCompound(
7148 Send node,
7149 LocalVariableElement variable,
7150 AssignmentOperator operator,
7151 Node rhs,
7152 A arg) {
7153 return handleLocalCompound(node, variable, operator, rhs, arg);
7154 }
7155
7156 @override
7157 R visitLocalVariablePostfix(
7158 Send node,
7159 LocalVariableElement variable,
7160 IncDecOperator operator,
7161 A arg) {
7162 return handleLocalPostfixPrefix(
7163 node, variable, operator, arg, isPrefix: false);
7164 }
7165
7166 @override
7167 R visitLocalVariablePrefix(
7168 Send node,
7169 LocalVariableElement variable,
7170 IncDecOperator operator,
7171 A arg) {
7172 return handleLocalPostfixPrefix(
7173 node, variable, operator, arg, isPrefix: true);
7174 }
7175
7176 @override
7177 R visitParameterCompound(
7178 Send node,
7179 ParameterElement parameter,
7180 AssignmentOperator operator,
7181 Node rhs,
7182 A arg) {
7183 return handleLocalCompound(node, parameter, operator, rhs, arg);
7184 }
7185
7186 @override
7187 R visitParameterPostfix(
7188 Send node,
7189 ParameterElement parameter,
7190 IncDecOperator operator,
7191 A arg) {
7192 return handleLocalPostfixPrefix(
7193 node, parameter, operator, arg, isPrefix: false);
7194 }
7195
7196 @override
7197 R visitParameterPrefix(
7198 Send node,
7199 ParameterElement parameter,
7200 IncDecOperator operator,
7201 A arg) {
7202 return handleLocalPostfixPrefix(
7203 node, parameter, operator, arg, isPrefix: true);
7204 }
7205 }
7206
7207 /// Mixin that groups all `visitConstantX` and `visitXTypeLiteralY` methods for 6113 /// Mixin that groups all `visitConstantX` and `visitXTypeLiteralY` methods for
7208 /// constant type literals by delegating calls to `handleConstantX` methods. 6114 /// constant type literals by delegating calls to `handleConstantX` methods.
7209 /// 6115 ///
7210 /// This mixin is useful for the cases where expressions on constants are 6116 /// This mixin is useful for the cases where expressions on constants are
7211 /// handled uniformly. 6117 /// handled uniformly.
7212 abstract class BaseImplementationOfConstantsMixin<R, A> 6118 abstract class BaseImplementationOfConstantsMixin<R, A>
7213 implements SemanticSendVisitor<R, A> { 6119 implements SemanticSendVisitor<R, A> {
7214 R handleConstantGet( 6120 R handleConstantGet(
7215 Node node, 6121 Node node,
7216 ConstantExpression constant, 6122 ConstantExpression constant,
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after
7297 R visitTypedefTypeLiteralInvoke( 6203 R visitTypedefTypeLiteralInvoke(
7298 Send node, 6204 Send node,
7299 ConstantExpression constant, 6205 ConstantExpression constant,
7300 NodeList arguments, 6206 NodeList arguments,
7301 CallStructure callStructure, 6207 CallStructure callStructure,
7302 A arg) { 6208 A arg) {
7303 return handleConstantInvoke(node, constant, arguments, callStructure, arg); 6209 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
7304 } 6210 }
7305 } 6211 }
7306 6212
7307 /// Mixin that groups all non-compound `visitDynamicPropertyX` and 6213 /// Mixin that groups all `visitDynamicPropertyX` and `visitThisPropertyY`
7308 /// `visitThisPropertyY` methods for by delegating calls to `handleDynamicX` 6214 /// methods for by delegating calls to `handleDynamicX` methods, providing
7309 /// methods, providing `null` as the receiver for the this properties. 6215 /// `null` as the receiver for the this properties.
7310 /// 6216 ///
7311 /// This mixin is useful for the cases where dynamic and this properties are 6217 /// This mixin is useful for the cases where dynamic and this properties are
7312 /// handled uniformly. 6218 /// handled uniformly.
7313 abstract class BaseImplementationOfDynamicsMixin<R, A> 6219 abstract class BaseImplementationOfDynamicsMixin<R, A>
7314 implements SemanticSendVisitor<R, A> { 6220 implements SemanticSendVisitor<R, A> {
6221 R handleDynamicCompound(
6222 Send node,
6223 Node receiver,
6224 AssignmentOperator operator,
6225 Node rhs,
6226 Selector getterSelector,
6227 Selector setterSelector,
6228 A arg);
6229
7315 R handleDynamicGet( 6230 R handleDynamicGet(
7316 Send node, 6231 Send node,
7317 Node receiver, 6232 Node receiver,
7318 Selector selector, 6233 Selector selector,
7319 A arg); 6234 A arg);
7320 6235
7321 R handleDynamicInvoke( 6236 R handleDynamicInvoke(
7322 Send node, 6237 Send node,
7323 Node receiver, 6238 Node receiver,
7324 NodeList arguments, 6239 NodeList arguments,
7325 Selector selector, 6240 Selector selector,
7326 A arg); 6241 A arg);
7327 6242
6243 R handleDynamicPostfixPrefix(
6244 Send node,
6245 Node receiver,
6246 IncDecOperator operator,
6247 Selector getterSelector,
6248 Selector setterSelector,
6249 A arg,
6250 {bool isPrefix});
6251
7328 R handleDynamicSet( 6252 R handleDynamicSet(
7329 SendSet node, 6253 SendSet node,
7330 Node receiver, 6254 Node receiver,
7331 Selector selector, 6255 Selector selector,
7332 Node rhs, 6256 Node rhs,
7333 A arg); 6257 A arg);
7334 6258
6259 R handleDynamicIndexPostfixPrefix(
6260 Send node,
6261 Node receiver,
6262 Node index,
6263 IncDecOperator operator,
6264 A arg,
6265 {bool isPrefix});
6266
6267 @override
6268 R visitDynamicPropertyCompound(
6269 Send node,
6270 Node receiver,
6271 AssignmentOperator operator,
6272 Node rhs,
6273 Selector getterSelector,
6274 Selector setterSelector,
6275 A arg) {
6276 return handleDynamicCompound(
6277 node, receiver, operator, rhs, getterSelector, setterSelector, arg);
6278 }
6279
7335 @override 6280 @override
7336 R visitDynamicPropertyGet( 6281 R visitDynamicPropertyGet(
7337 Send node, 6282 Send node,
7338 Node receiver, 6283 Node receiver,
7339 Selector selector, 6284 Selector selector,
7340 A arg) { 6285 A arg) {
7341 return handleDynamicGet(node, receiver, selector, arg); 6286 return handleDynamicGet(node, receiver, selector, arg);
7342 } 6287 }
7343 6288
7344 @override 6289 @override
7345 R visitDynamicPropertyInvoke( 6290 R visitDynamicPropertyInvoke(
7346 Send node, 6291 Send node,
7347 Node receiver, 6292 Node receiver,
7348 NodeList arguments, 6293 NodeList arguments,
7349 Selector selector, 6294 Selector selector,
7350 A arg) { 6295 A arg) {
7351 return handleDynamicInvoke(node, receiver, arguments, selector, arg); 6296 return handleDynamicInvoke(node, receiver, arguments, selector, arg);
7352 } 6297 }
7353 6298
7354 @override 6299 @override
6300 R visitDynamicPropertyPostfix(
6301 Send node,
6302 Node receiver,
6303 IncDecOperator operator,
6304 Selector getterSelector,
6305 Selector setterSelector,
6306 A arg) {
6307 return handleDynamicPostfixPrefix(
6308 node, receiver, operator,
6309 getterSelector, setterSelector, arg, isPrefix: false);
6310 }
6311
6312 @override
6313 R visitDynamicPropertyPrefix(
6314 Send node,
6315 Node receiver,
6316 IncDecOperator operator,
6317 Selector getterSelector,
6318 Selector setterSelector,
6319 A arg) {
6320 return handleDynamicPostfixPrefix(
6321 node, receiver, operator,
6322 getterSelector, setterSelector, arg, isPrefix: true);
6323 }
6324
6325 @override
7355 R visitDynamicPropertySet( 6326 R visitDynamicPropertySet(
7356 SendSet node, 6327 SendSet node,
7357 Node receiver, 6328 Node receiver,
7358 Selector selector, 6329 Selector selector,
7359 Node rhs, 6330 Node rhs,
7360 A arg) { 6331 A arg) {
7361 return handleDynamicSet(node, receiver, selector, rhs, arg); 6332 return handleDynamicSet(node, receiver, selector, rhs, arg);
7362 } 6333 }
7363 6334
7364 @override 6335 @override
6336 R visitThisPropertyCompound(
6337 Send node,
6338 AssignmentOperator operator,
6339 Node rhs,
6340 Selector getterSelector,
6341 Selector setterSelector,
6342 A arg) {
6343 return handleDynamicCompound(
6344 node, null, operator, rhs, getterSelector, setterSelector, arg);
6345 }
6346
6347 @override
7365 R visitThisPropertyGet( 6348 R visitThisPropertyGet(
7366 Send node, 6349 Send node,
7367 Selector selector, 6350 Selector selector,
7368 A arg) { 6351 A arg) {
7369 return handleDynamicGet(node, null, selector, arg); 6352 return handleDynamicGet(node, null, selector, arg);
7370 } 6353 }
7371 6354
7372 @override 6355 @override
7373 R visitThisPropertyInvoke( 6356 R visitThisPropertyInvoke(
7374 Send node, 6357 Send node,
7375 NodeList arguments, 6358 NodeList arguments,
7376 Selector selector, 6359 Selector selector,
7377 A arg) { 6360 A arg) {
7378 return handleDynamicInvoke(node, null, arguments, selector, arg); 6361 return handleDynamicInvoke(node, null, arguments, selector, arg);
7379 } 6362 }
7380 6363
7381 @override 6364 @override
6365 R visitThisPropertyPostfix(
6366 Send node,
6367 IncDecOperator operator,
6368 Selector getterSelector,
6369 Selector setterSelector,
6370 A arg) {
6371 return handleDynamicPostfixPrefix(
6372 node, null, operator,
6373 getterSelector, setterSelector, arg, isPrefix: false);
6374 }
6375
6376 @override
6377 R visitThisPropertyPrefix(
6378 Send node,
6379 IncDecOperator operator,
6380 Selector getterSelector,
6381 Selector setterSelector,
6382 A arg) {
6383 return handleDynamicPostfixPrefix(
6384 node, null, operator,
6385 getterSelector, setterSelector, arg, isPrefix: true);
6386 }
6387
6388 @override
7382 R visitThisPropertySet( 6389 R visitThisPropertySet(
7383 SendSet node, 6390 SendSet node,
7384 Selector selector, 6391 Selector selector,
7385 Node rhs, 6392 Node rhs,
7386 A arg) { 6393 A arg) {
7387 return handleDynamicSet(node, null, selector, rhs, arg); 6394 return handleDynamicSet(node, null, selector, rhs, arg);
7388 } 6395 }
7389 } 6396
7390 6397 @override
7391 /// Mixin that groups all compounds of `visitDynamicPropertyX` and
7392 /// `visitThisPropertyY` methods for by delegating calls to `handleDynamicX`
7393 /// methods, providing `null` as the receiver for the this properties.
7394 ///
7395 /// This mixin is useful for the cases where dynamic and this properties are
7396 /// handled uniformly.
7397 abstract class BaseImplementationOfDynamicCompoundsMixin<R, A>
7398 implements SemanticSendVisitor<R, A> {
7399 R handleDynamicCompound(
7400 Send node,
7401 Node receiver,
7402 AssignmentOperator operator,
7403 Node rhs,
7404 Selector getterSelector,
7405 Selector setterSelector,
7406 A arg);
7407
7408 R handleDynamicPostfixPrefix(
7409 Send node,
7410 Node receiver,
7411 IncDecOperator operator,
7412 Selector getterSelector,
7413 Selector setterSelector,
7414 A arg,
7415 {bool isPrefix});
7416
7417 R handleDynamicIndexPostfixPrefix(
7418 Send node,
7419 Node receiver,
7420 Node index,
7421 IncDecOperator operator,
7422 A arg,
7423 {bool isPrefix});
7424
7425 @override
7426 R visitDynamicPropertyCompound(
7427 Send node,
7428 Node receiver,
7429 AssignmentOperator operator,
7430 Node rhs,
7431 Selector getterSelector,
7432 Selector setterSelector,
7433 A arg) {
7434 return handleDynamicCompound(
7435 node, receiver, operator, rhs, getterSelector, setterSelector, arg);
7436 }
7437
7438 @override
7439 R visitDynamicPropertyPostfix(
7440 Send node,
7441 Node receiver,
7442 IncDecOperator operator,
7443 Selector getterSelector,
7444 Selector setterSelector,
7445 A arg) {
7446 return handleDynamicPostfixPrefix(
7447 node, receiver, operator,
7448 getterSelector, setterSelector, arg, isPrefix: false);
7449 }
7450
7451 @override
7452 R visitDynamicPropertyPrefix(
7453 Send node,
7454 Node receiver,
7455 IncDecOperator operator,
7456 Selector getterSelector,
7457 Selector setterSelector,
7458 A arg) {
7459 return handleDynamicPostfixPrefix(
7460 node, receiver, operator,
7461 getterSelector, setterSelector, arg, isPrefix: true);
7462 }
7463
7464 @override
7465 R visitThisPropertyCompound(
7466 Send node,
7467 AssignmentOperator operator,
7468 Node rhs,
7469 Selector getterSelector,
7470 Selector setterSelector,
7471 A arg) {
7472 return handleDynamicCompound(
7473 node, null, operator, rhs, getterSelector, setterSelector, arg);
7474 }
7475
7476 @override
7477 R visitThisPropertyPostfix(
7478 Send node,
7479 IncDecOperator operator,
7480 Selector getterSelector,
7481 Selector setterSelector,
7482 A arg) {
7483 return handleDynamicPostfixPrefix(
7484 node, null, operator,
7485 getterSelector, setterSelector, arg, isPrefix: false);
7486 }
7487
7488 @override
7489 R visitThisPropertyPrefix(
7490 Send node,
7491 IncDecOperator operator,
7492 Selector getterSelector,
7493 Selector setterSelector,
7494 A arg) {
7495 return handleDynamicPostfixPrefix(
7496 node, null, operator,
7497 getterSelector, setterSelector, arg, isPrefix: true);
7498 }
7499
7500 @override
7501 R visitIndexPostfix(
7502 Send node,
7503 Node receiver,
7504 Node index,
7505 IncDecOperator operator,
7506 A arg) {
7507 return handleDynamicIndexPostfixPrefix(
7508 node, receiver, index, operator, arg, isPrefix: false);
7509 }
7510
7511 @override
7512 R visitIndexPrefix(
7513 Send node,
7514 Node receiver,
7515 Node index,
7516 IncDecOperator operator,
7517 A arg) {
7518 return handleDynamicIndexPostfixPrefix(
7519 node, receiver, index, operator, arg, isPrefix: true);
7520 }
7521 }
7522
7523 /// The getter kind for statically resolved compound expressions.
7524 enum CompoundGetter {
7525 /// The compound reads from a field.
7526 FIELD,
7527
7528 /// The compound reads from a getter.
7529 GETTER,
7530
7531 /// The compound reads (closurizes) a method.
7532 METHOD,
7533
7534 /// The getter is unresolved. The accompanied element is an erroneous element.
7535 UNRESOLVED,
7536 }
7537
7538 /// The setter kind for statically resolved compound expressions.
7539 enum CompoundSetter {
7540 /// The compound writes to a field.
7541 FIELD,
7542
7543 /// The compound writes to a setter.
7544 SETTER,
7545
7546 /// The setter is unresolved or unassignable. The accompanied element may be
7547 /// `null`, and erroneous element, or the unassignable element.
7548 INVALID,
7549 }
7550
7551 /// The kind of a [CompoundRhs].
7552 enum CompoundKind {
7553 /// A prefix expression, like `--a`.
7554 PREFIX,
7555
7556 /// A postfix expression, like `a++`.
7557 POSTFIX,
7558
7559 /// A compound assignment, like `a *= b`.
7560 ASSIGNMENT,
7561 }
7562
7563 /// The right-hand side of a compound expression.
7564 abstract class CompoundRhs {
7565 /// The kind of compound.
7566 CompoundKind get kind;
7567
7568 /// The binary operator implied by the compound operator.
7569 BinaryOperator get operator;
7570
7571 /// The explicit right hand side in case of a compound assignment, `null`
7572 /// otherwise.
7573 Node get rhs;
7574 }
7575
7576 /// A prefix or postfix of [incDecOperator].
7577 class IncDecCompound implements CompoundRhs {
7578 final CompoundKind kind;
7579 final IncDecOperator incDecOperator;
7580
7581 IncDecCompound(this.kind, this.incDecOperator);
7582
7583 BinaryOperator get operator => incDecOperator.binaryOperator;
7584
7585 Node get rhs => null;
7586 }
7587
7588 /// A compound assignment with [assignmentOperator] and [rhs].
7589 class AssignmentCompound implements CompoundRhs {
7590 final AssignmentOperator assignmentOperator;
7591 final Node rhs;
7592
7593 AssignmentCompound(this.assignmentOperator, this.rhs);
7594
7595 CompoundKind get kind => CompoundKind.ASSIGNMENT;
7596
7597 BinaryOperator get operator => assignmentOperator.binaryOperator;
7598 }
7599
7600 /// Simplified handling of compound assignments and prefix/postfix expressions.
7601 abstract class BaseImplementationOfCompoundsMixin<R, A>
7602 implements SemanticSendVisitor<R, A> {
7603
7604 /// Handle a super compounds, like `super.foo += 42` or `--super.bar`.
7605 R handleSuperCompounds(
7606 SendSet node,
7607 Element getter,
7608 CompoundGetter getterKind,
7609 Element setter,
7610 CompoundSetter setterKind,
7611 CompoundRhs rhs,
7612 A arg);
7613
7614 /// Handle a static or top level compounds, like `foo += 42` or `--bar`.
7615 R handleStaticCompounds(
7616 SendSet node,
7617 Element getter,
7618 CompoundGetter getterKind,
7619 Element setter,
7620 CompoundSetter setterKind,
7621 CompoundRhs rhs,
7622 A arg);
7623
7624 /// Handle a local compounds, like `foo += 42` or `--bar`. If [isSetterValid]
7625 /// is false [local] is unassignable.
7626 R handleLocalCompounds(
7627 SendSet node,
7628 LocalElement local,
7629 CompoundRhs rhs,
7630 A arg,
7631 {bool isSetterValid});
7632
7633 /// Handle a compounds on a type literal constant, like `Object += 42` or
7634 /// `--Object`.
7635 R handleTypeLiteralConstantCompounds(
7636 SendSet node,
7637 ConstantExpression constant,
7638 CompoundRhs rhs,
7639 A arg);
7640
7641 /// Handle a compounds on a type variable type literal, like `T += 42` or
7642 /// `--T`.
7643 R handleTypeVariableTypeLiteralCompounds(
7644 SendSet node,
7645 TypeVariableElement typeVariable,
7646 CompoundRhs rhs,
7647 A arg);
7648
7649 /// Handle a dynamic compounds, like `o.foo += 42` or `--o.foo`. [receiver] is
7650 /// `null` for properties on `this`, like `--this.foo` or `--foo`.
7651 R handleDynamicCompounds(
7652 Send node,
7653 Node receiver,
7654 CompoundRhs rhs,
7655 Selector getterSelector,
7656 Selector setterSelector,
7657 A arg);
7658
7659 R visitDynamicPropertyCompound(
7660 Send node,
7661 Node receiver,
7662 AssignmentOperator operator,
7663 Node rhs,
7664 Selector getterSelector,
7665 Selector setterSelector,
7666 A arg) {
7667 return handleDynamicCompounds(
7668 node,
7669 receiver,
7670 new AssignmentCompound(operator, rhs),
7671 getterSelector,
7672 setterSelector,
7673 arg);
7674 }
7675
7676 @override
7677 R visitThisPropertyCompound(
7678 Send node,
7679 AssignmentOperator operator,
7680 Node rhs,
7681 Selector getterSelector,
7682 Selector setterSelector,
7683 A arg) {
7684 return handleDynamicCompounds(
7685 node,
7686 null,
7687 new AssignmentCompound(operator, rhs),
7688 getterSelector,
7689 setterSelector,
7690 arg);
7691 }
7692
7693 @override
7694 R visitParameterCompound(
7695 Send node,
7696 ParameterElement parameter,
7697 AssignmentOperator operator,
7698 Node rhs,
7699 A arg) {
7700 return handleLocalCompounds(
7701 node,
7702 parameter,
7703 new AssignmentCompound(operator, rhs),
7704 arg,
7705 isSetterValid: true);
7706 }
7707
7708 @override
7709 R visitFinalParameterCompound(
7710 Send node,
7711 ParameterElement parameter,
7712 AssignmentOperator operator,
7713 Node rhs,
7714 A arg) {
7715 return handleLocalCompounds(
7716 node,
7717 parameter,
7718 new AssignmentCompound(operator, rhs),
7719 arg,
7720 isSetterValid: false);
7721 }
7722
7723 @override
7724 R visitLocalVariableCompound(
7725 Send node,
7726 LocalVariableElement variable,
7727 AssignmentOperator operator,
7728 Node rhs,
7729 A arg) {
7730 return handleLocalCompounds(
7731 node,
7732 variable,
7733 new AssignmentCompound(operator, rhs),
7734 arg,
7735 isSetterValid: true);
7736 }
7737
7738 @override
7739 R visitFinalLocalVariableCompound(
7740 Send node,
7741 LocalVariableElement variable,
7742 AssignmentOperator operator,
7743 Node rhs,
7744 A arg) {
7745 return handleLocalCompounds(
7746 node,
7747 variable,
7748 new AssignmentCompound(operator, rhs),
7749 arg,
7750 isSetterValid: false);
7751 }
7752
7753 @override
7754 R visitLocalFunctionCompound(
7755 Send node,
7756 LocalFunctionElement function,
7757 AssignmentOperator operator,
7758 Node rhs,
7759 A arg) {
7760 return handleLocalCompounds(
7761 node,
7762 function,
7763 new AssignmentCompound(operator, rhs),
7764 arg,
7765 isSetterValid: false);
7766 }
7767
7768 @override
7769 R visitStaticFieldCompound(
7770 Send node,
7771 FieldElement field,
7772 AssignmentOperator operator,
7773 Node rhs,
7774 A arg) {
7775 return handleStaticCompounds(
7776 node,
7777 field, CompoundGetter.FIELD,
7778 field, CompoundSetter.FIELD,
7779 new AssignmentCompound(operator, rhs),
7780 arg);
7781 }
7782
7783 @override
7784 R visitFinalStaticFieldCompound(
7785 Send node,
7786 FieldElement field,
7787 AssignmentOperator operator,
7788 Node rhs,
7789 A arg) {
7790 return handleStaticCompounds(
7791 node,
7792 field, CompoundGetter.FIELD,
7793 null, CompoundSetter.INVALID,
7794 new AssignmentCompound(operator, rhs),
7795 arg);
7796 }
7797
7798 @override
7799 R visitStaticGetterSetterCompound(
7800 Send node,
7801 FunctionElement getter,
7802 FunctionElement setter,
7803 AssignmentOperator operator,
7804 Node rhs,
7805 A arg) {
7806 return handleStaticCompounds(
7807 node,
7808 getter, CompoundGetter.GETTER,
7809 setter, CompoundSetter.SETTER,
7810 new AssignmentCompound(operator, rhs),
7811 arg);
7812 }
7813
7814 @override
7815 R visitStaticMethodSetterCompound(
7816 Send node,
7817 FunctionElement method,
7818 FunctionElement setter,
7819 AssignmentOperator operator,
7820 Node rhs,
7821 A arg) {
7822 return handleStaticCompounds(
7823 node,
7824 method, CompoundGetter.METHOD,
7825 setter, CompoundSetter.SETTER,
7826 new AssignmentCompound(operator, rhs),
7827 arg);
7828 }
7829
7830 @override
7831 R visitTopLevelFieldCompound(
7832 Send node,
7833 FieldElement field,
7834 AssignmentOperator operator,
7835 Node rhs,
7836 A arg) {
7837 return handleStaticCompounds(
7838 node,
7839 field, CompoundGetter.FIELD,
7840 field, CompoundSetter.FIELD,
7841 new AssignmentCompound(operator, rhs),
7842 arg);
7843 }
7844
7845 @override
7846 R visitFinalTopLevelFieldCompound(
7847 Send node,
7848 FieldElement field,
7849 AssignmentOperator operator,
7850 Node rhs,
7851 A arg) {
7852 return handleStaticCompounds(
7853 node,
7854 field, CompoundGetter.FIELD,
7855 null, CompoundSetter.INVALID,
7856 new AssignmentCompound(operator, rhs),
7857 arg);
7858 }
7859
7860 @override
7861 R visitTopLevelGetterSetterCompound(
7862 Send node,
7863 FunctionElement getter,
7864 FunctionElement setter,
7865 AssignmentOperator operator,
7866 Node rhs,
7867 A arg) {
7868 return handleStaticCompounds(
7869 node,
7870 getter, CompoundGetter.GETTER,
7871 setter, CompoundSetter.SETTER,
7872 new AssignmentCompound(operator, rhs),
7873 arg);
7874 }
7875
7876 @override
7877 R visitTopLevelMethodSetterCompound(
7878 Send node,
7879 FunctionElement method,
7880 FunctionElement setter,
7881 AssignmentOperator operator,
7882 Node rhs,
7883 A arg) {
7884 return handleStaticCompounds(
7885 node,
7886 method, CompoundGetter.METHOD,
7887 setter, CompoundSetter.SETTER,
7888 new AssignmentCompound(operator, rhs),
7889 arg);
7890 }
7891
7892 @override
7893 R visitSuperFieldCompound(
7894 Send node,
7895 FieldElement field,
7896 AssignmentOperator operator,
7897 Node rhs,
7898 A arg) {
7899 return handleSuperCompounds(
7900 node,
7901 field, CompoundGetter.FIELD,
7902 field, CompoundSetter.FIELD,
7903 new AssignmentCompound(operator, rhs),
7904 arg);
7905 }
7906
7907 @override
7908 R visitFinalSuperFieldCompound(
7909 Send node,
7910 FieldElement field,
7911 AssignmentOperator operator,
7912 Node rhs,
7913 A arg) {
7914 return handleSuperCompounds(
7915 node,
7916 field, CompoundGetter.FIELD,
7917 field, CompoundSetter.INVALID,
7918 new AssignmentCompound(operator, rhs),
7919 arg);
7920 }
7921
7922 @override
7923 R visitSuperGetterSetterCompound(
7924 Send node,
7925 FunctionElement getter,
7926 FunctionElement setter,
7927 AssignmentOperator operator,
7928 Node rhs,
7929 A arg) {
7930 return handleSuperCompounds(
7931 node,
7932 getter, CompoundGetter.GETTER,
7933 setter, CompoundSetter.SETTER,
7934 new AssignmentCompound(operator, rhs),
7935 arg);
7936 }
7937
7938 @override
7939 R visitSuperMethodSetterCompound(
7940 Send node,
7941 FunctionElement method,
7942 FunctionElement setter,
7943 AssignmentOperator operator,
7944 Node rhs,
7945 A arg) {
7946 return handleSuperCompounds(
7947 node,
7948 method, CompoundGetter.METHOD,
7949 setter, CompoundSetter.SETTER,
7950 new AssignmentCompound(operator, rhs),
7951 arg);
7952 }
7953
7954 @override
7955 R visitSuperFieldSetterCompound(
7956 Send node,
7957 FieldElement field,
7958 FunctionElement setter,
7959 AssignmentOperator operator,
7960 Node rhs,
7961 A arg) {
7962 return handleSuperCompounds(
7963 node,
7964 field, CompoundGetter.FIELD,
7965 setter, CompoundSetter.SETTER,
7966 new AssignmentCompound(operator, rhs),
7967 arg);
7968 }
7969
7970 @override
7971 R visitSuperGetterFieldCompound(
7972 Send node,
7973 FunctionElement getter,
7974 FieldElement field,
7975 AssignmentOperator operator,
7976 Node rhs,
7977 A arg) {
7978 return handleSuperCompounds(
7979 node,
7980 getter, CompoundGetter.GETTER,
7981 field, CompoundSetter.FIELD,
7982 new AssignmentCompound(operator, rhs),
7983 arg);
7984 }
7985
7986 @override
7987 R visitClassTypeLiteralCompound(
7988 Send node,
7989 ConstantExpression constant,
7990 AssignmentOperator operator,
7991 Node rhs,
7992 A arg) {
7993 return handleTypeLiteralConstantCompounds(
7994 node,
7995 constant,
7996 new AssignmentCompound(operator, rhs),
7997 arg);
7998 }
7999
8000 @override
8001 R visitTypedefTypeLiteralCompound(
8002 Send node,
8003 ConstantExpression constant,
8004 AssignmentOperator operator,
8005 Node rhs,
8006 A arg) {
8007 return handleTypeLiteralConstantCompounds(
8008 node,
8009 constant,
8010 new AssignmentCompound(operator, rhs),
8011 arg);
8012 }
8013
8014 @override
8015 R visitTypeVariableTypeLiteralCompound(
8016 Send node,
8017 TypeVariableElement element,
8018 AssignmentOperator operator,
8019 Node rhs,
8020 A arg) {
8021 return handleTypeVariableTypeLiteralCompounds(
8022 node,
8023 element,
8024 new AssignmentCompound(operator, rhs),
8025 arg);
8026 }
8027
8028 @override
8029 R visitDynamicTypeLiteralCompound(
8030 Send node,
8031 ConstantExpression constant,
8032 AssignmentOperator operator,
8033 Node rhs,
8034 A arg) {
8035 return handleTypeLiteralConstantCompounds(
8036 node,
8037 constant,
8038 new AssignmentCompound(operator, rhs),
8039 arg);
8040 }
8041
8042
8043 R visitDynamicPropertyPrefix(
8044 Send node,
8045 Node receiver,
8046 IncDecOperator operator,
8047 Selector getterSelector,
8048 Selector setterSelector,
8049 A arg) {
8050 return handleDynamicCompounds(
8051 node,
8052 receiver,
8053 new IncDecCompound(CompoundKind.PREFIX, operator),
8054 getterSelector,
8055 setterSelector,
8056 arg);
8057 }
8058
8059 @override
8060 R visitParameterPrefix(
8061 Send node,
8062 ParameterElement parameter,
8063 IncDecOperator operator,
8064 A arg) {
8065 return handleLocalCompounds(
8066 node,
8067 parameter,
8068 new IncDecCompound(CompoundKind.PREFIX, operator),
8069 arg,
8070 isSetterValid: true);
8071 }
8072
8073 @override
8074 R visitLocalVariablePrefix(
8075 Send node,
8076 LocalVariableElement variable,
8077 IncDecOperator operator,
8078 A arg) {
8079 return handleLocalCompounds(
8080 node,
8081 variable,
8082 new IncDecCompound(CompoundKind.PREFIX, operator),
8083 arg,
8084 isSetterValid: true);
8085 }
8086
8087 @override
8088 R visitLocalFunctionPrefix(
8089 Send node,
8090 LocalFunctionElement function,
8091 IncDecOperator operator,
8092 A arg) {
8093 return handleLocalCompounds(
8094 node,
8095 function,
8096 new IncDecCompound(CompoundKind.PREFIX, operator),
8097 arg,
8098 isSetterValid: false);
8099 }
8100
8101
8102 R visitThisPropertyPrefix(
8103 Send node,
8104 IncDecOperator operator,
8105 Selector getterSelector,
8106 Selector setterSelector,
8107 A arg) {
8108 return handleDynamicCompounds(
8109 node,
8110 null,
8111 new IncDecCompound(CompoundKind.PREFIX, operator),
8112 getterSelector,
8113 setterSelector,
8114 arg);
8115 }
8116
8117 @override
8118 R visitStaticFieldPrefix(
8119 Send node,
8120 FieldElement field,
8121 IncDecOperator operator,
8122 A arg) {
8123 return handleStaticCompounds(
8124 node,
8125 field, CompoundGetter.FIELD,
8126 field, CompoundSetter.FIELD,
8127 new IncDecCompound(CompoundKind.PREFIX, operator),
8128 arg);
8129 }
8130
8131 @override
8132 R visitStaticGetterSetterPrefix(
8133 Send node,
8134 FunctionElement getter,
8135 FunctionElement setter,
8136 IncDecOperator operator,
8137 A arg) {
8138 return handleStaticCompounds(
8139 node,
8140 getter, CompoundGetter.GETTER,
8141 setter, CompoundSetter.SETTER,
8142 new IncDecCompound(CompoundKind.PREFIX, operator),
8143 arg);
8144 }
8145
8146
8147 R visitStaticMethodSetterPrefix(
8148 Send node,
8149 FunctionElement getter,
8150 FunctionElement setter,
8151 IncDecOperator operator,
8152 A arg) {
8153 return handleStaticCompounds(
8154 node,
8155 getter, CompoundGetter.METHOD,
8156 setter, CompoundSetter.SETTER,
8157 new IncDecCompound(CompoundKind.PREFIX, operator),
8158 arg);
8159 }
8160
8161 @override
8162 R visitTopLevelFieldPrefix(
8163 Send node,
8164 FieldElement field,
8165 IncDecOperator operator,
8166 A arg) {
8167 return handleStaticCompounds(
8168 node,
8169 field, CompoundGetter.FIELD,
8170 field, CompoundSetter.FIELD,
8171 new IncDecCompound(CompoundKind.PREFIX, operator),
8172 arg);
8173 }
8174
8175 @override
8176 R visitTopLevelGetterSetterPrefix(
8177 Send node,
8178 FunctionElement getter,
8179 FunctionElement setter,
8180 IncDecOperator operator,
8181 A arg) {
8182 return handleStaticCompounds(
8183 node,
8184 getter, CompoundGetter.GETTER,
8185 setter, CompoundSetter.SETTER,
8186 new IncDecCompound(CompoundKind.PREFIX, operator),
8187 arg);
8188 }
8189
8190 @override
8191 R visitTopLevelMethodSetterPrefix(
8192 Send node,
8193 FunctionElement method,
8194 FunctionElement setter,
8195 IncDecOperator operator,
8196 A arg) {
8197 return handleStaticCompounds(
8198 node,
8199 method, CompoundGetter.METHOD,
8200 setter, CompoundSetter.SETTER,
8201 new IncDecCompound(CompoundKind.PREFIX, operator),
8202 arg);
8203 }
8204
8205 @override
8206 R visitSuperFieldPrefix(
8207 Send node,
8208 FieldElement field,
8209 IncDecOperator operator,
8210 A arg) {
8211 return handleSuperCompounds(
8212 node,
8213 field, CompoundGetter.FIELD,
8214 field, CompoundSetter.FIELD,
8215 new IncDecCompound(CompoundKind.PREFIX, operator),
8216 arg);
8217 }
8218
8219 @override
8220 R visitSuperFieldFieldPrefix(
8221 Send node,
8222 FieldElement readField,
8223 FieldElement writtenField,
8224 IncDecOperator operator,
8225 A arg) {
8226 return handleSuperCompounds(
8227 node,
8228 readField, CompoundGetter.FIELD,
8229 writtenField, CompoundSetter.FIELD,
8230 new IncDecCompound(CompoundKind.PREFIX, operator),
8231 arg);
8232 }
8233
8234 @override
8235 R visitSuperFieldSetterPrefix(
8236 Send node,
8237 FieldElement field,
8238 FunctionElement setter,
8239 IncDecOperator operator,
8240 A arg) {
8241 return handleSuperCompounds(
8242 node,
8243 field, CompoundGetter.FIELD,
8244 setter, CompoundSetter.SETTER,
8245 new IncDecCompound(CompoundKind.PREFIX, operator),
8246 arg);
8247 }
8248
8249
8250 R visitSuperGetterSetterPrefix(
8251 Send node,
8252 FunctionElement getter,
8253 FunctionElement setter,
8254 IncDecOperator operator,
8255 A arg) {
8256 return handleSuperCompounds(
8257 node,
8258 getter, CompoundGetter.GETTER,
8259 setter, CompoundSetter.SETTER,
8260 new IncDecCompound(CompoundKind.PREFIX, operator),
8261 arg);
8262 }
8263
8264 @override
8265 R visitSuperGetterFieldPrefix(
8266 Send node,
8267 FunctionElement getter,
8268 FieldElement field,
8269 IncDecOperator operator,
8270 A arg) {
8271 return handleSuperCompounds(
8272 node,
8273 getter, CompoundGetter.GETTER,
8274 field, CompoundSetter.FIELD,
8275 new IncDecCompound(CompoundKind.PREFIX, operator),
8276 arg);
8277 }
8278
8279 @override
8280 R visitSuperMethodSetterPrefix(
8281 Send node,
8282 FunctionElement method,
8283 FunctionElement setter,
8284 IncDecOperator operator,
8285 A arg) {
8286 return handleSuperCompounds(
8287 node,
8288 method, CompoundGetter.METHOD,
8289 setter, CompoundSetter.SETTER,
8290 new IncDecCompound(CompoundKind.PREFIX, operator),
8291 arg);
8292 }
8293
8294 @override
8295 R visitClassTypeLiteralPrefix(
8296 Send node,
8297 ConstantExpression constant,
8298 IncDecOperator operator,
8299 A arg) {
8300 return handleTypeLiteralConstantCompounds(
8301 node,
8302 constant,
8303 new IncDecCompound(CompoundKind.PREFIX, operator),
8304 arg);
8305 }
8306
8307 @override
8308 R visitTypedefTypeLiteralPrefix(
8309 Send node,
8310 ConstantExpression constant,
8311 IncDecOperator operator,
8312 A arg) {
8313 return handleTypeLiteralConstantCompounds(
8314 node,
8315 constant,
8316 new IncDecCompound(CompoundKind.PREFIX, operator),
8317 arg);
8318 }
8319
8320 @override
8321 R visitTypeVariableTypeLiteralPrefix(
8322 Send node,
8323 TypeVariableElement element,
8324 IncDecOperator operator,
8325 A arg) {
8326 return handleTypeVariableTypeLiteralCompounds(
8327 node,
8328 element,
8329 new IncDecCompound(CompoundKind.PREFIX, operator),
8330 arg);
8331 }
8332
8333 @override
8334 R visitDynamicTypeLiteralPrefix(
8335 Send node,
8336 ConstantExpression constant,
8337 IncDecOperator operator,
8338 A arg) {
8339 return handleTypeLiteralConstantCompounds(
8340 node,
8341 constant,
8342 new IncDecCompound(CompoundKind.PREFIX, operator),
8343 arg);
8344 }
8345
8346 @override
8347 R visitDynamicPropertyPostfix(
8348 Send node,
8349 Node receiver,
8350 IncDecOperator operator,
8351 Selector getterSelector,
8352 Selector setterSelector,
8353 A arg) {
8354 return handleDynamicCompounds(
8355 node,
8356 receiver,
8357 new IncDecCompound(CompoundKind.POSTFIX, operator),
8358 getterSelector,
8359 setterSelector,
8360 arg);
8361 }
8362
8363 @override
8364 R visitParameterPostfix(
8365 Send node,
8366 ParameterElement parameter,
8367 IncDecOperator operator,
8368 A arg) {
8369 return handleLocalCompounds(
8370 node,
8371 parameter,
8372 new IncDecCompound(CompoundKind.POSTFIX, operator),
8373 arg,
8374 isSetterValid: true);
8375 }
8376
8377 @override
8378 R visitLocalVariablePostfix(
8379 Send node,
8380 LocalVariableElement variable,
8381 IncDecOperator operator,
8382 A arg) {
8383 return handleLocalCompounds(
8384 node,
8385 variable,
8386 new IncDecCompound(CompoundKind.POSTFIX, operator),
8387 arg,
8388 isSetterValid: true);
8389 }
8390
8391 @override
8392 R visitLocalFunctionPostfix(
8393 Send node,
8394 LocalFunctionElement function,
8395 IncDecOperator operator,
8396 A arg) {
8397 return handleLocalCompounds(
8398 node,
8399 function,
8400 new IncDecCompound(CompoundKind.POSTFIX, operator),
8401 arg,
8402 isSetterValid: false);
8403 }
8404
8405
8406 R visitThisPropertyPostfix(
8407 Send node,
8408 IncDecOperator operator,
8409 Selector getterSelector,
8410 Selector setterSelector,
8411 A arg) {
8412 return handleDynamicCompounds(
8413 node,
8414 null,
8415 new IncDecCompound(CompoundKind.POSTFIX, operator),
8416 getterSelector,
8417 setterSelector,
8418 arg);
8419 }
8420
8421 @override
8422 R visitStaticFieldPostfix(
8423 Send node,
8424 FieldElement field,
8425 IncDecOperator operator,
8426 A arg) {
8427 return handleStaticCompounds(
8428 node,
8429 field, CompoundGetter.FIELD,
8430 field, CompoundSetter.FIELD,
8431 new IncDecCompound(CompoundKind.POSTFIX, operator),
8432 arg);
8433 }
8434
8435 @override
8436 R visitStaticGetterSetterPostfix(
8437 Send node,
8438 FunctionElement getter,
8439 FunctionElement setter,
8440 IncDecOperator operator,
8441 A arg) {
8442 return handleStaticCompounds(
8443 node,
8444 getter, CompoundGetter.GETTER,
8445 setter, CompoundSetter.SETTER,
8446 new IncDecCompound(CompoundKind.POSTFIX, operator),
8447 arg);
8448 }
8449
8450
8451 R visitStaticMethodSetterPostfix(
8452 Send node,
8453 FunctionElement getter,
8454 FunctionElement setter,
8455 IncDecOperator operator,
8456 A arg) {
8457 return handleStaticCompounds(
8458 node,
8459 getter, CompoundGetter.METHOD,
8460 setter, CompoundSetter.SETTER,
8461 new IncDecCompound(CompoundKind.POSTFIX, operator),
8462 arg);
8463 }
8464
8465 @override
8466 R visitTopLevelFieldPostfix(
8467 Send node,
8468 FieldElement field,
8469 IncDecOperator operator,
8470 A arg) {
8471 return handleStaticCompounds(
8472 node,
8473 field, CompoundGetter.FIELD,
8474 field, CompoundSetter.FIELD,
8475 new IncDecCompound(CompoundKind.POSTFIX, operator),
8476 arg);
8477 }
8478
8479 @override
8480 R visitTopLevelGetterSetterPostfix(
8481 Send node,
8482 FunctionElement getter,
8483 FunctionElement setter,
8484 IncDecOperator operator,
8485 A arg) {
8486 return handleStaticCompounds(
8487 node,
8488 getter, CompoundGetter.GETTER,
8489 setter, CompoundSetter.SETTER,
8490 new IncDecCompound(CompoundKind.POSTFIX, operator),
8491 arg);
8492 }
8493
8494 @override
8495 R visitTopLevelMethodSetterPostfix(
8496 Send node,
8497 FunctionElement method,
8498 FunctionElement setter,
8499 IncDecOperator operator,
8500 A arg) {
8501 return handleStaticCompounds(
8502 node,
8503 method, CompoundGetter.METHOD,
8504 setter, CompoundSetter.SETTER,
8505 new IncDecCompound(CompoundKind.POSTFIX, operator),
8506 arg);
8507 }
8508
8509 @override
8510 R visitSuperFieldPostfix(
8511 Send node,
8512 FieldElement field,
8513 IncDecOperator operator,
8514 A arg) {
8515 return handleSuperCompounds(
8516 node,
8517 field, CompoundGetter.FIELD,
8518 field, CompoundSetter.FIELD,
8519 new IncDecCompound(CompoundKind.POSTFIX, operator),
8520 arg);
8521 }
8522
8523 @override
8524 R visitSuperFieldFieldPostfix(
8525 Send node,
8526 FieldElement readField,
8527 FieldElement writtenField,
8528 IncDecOperator operator,
8529 A arg) {
8530 return handleSuperCompounds(
8531 node,
8532 readField, CompoundGetter.FIELD,
8533 writtenField, CompoundSetter.FIELD,
8534 new IncDecCompound(CompoundKind.POSTFIX, operator),
8535 arg);
8536 }
8537
8538 @override
8539 R visitSuperFieldSetterPostfix(
8540 Send node,
8541 FieldElement field,
8542 FunctionElement setter,
8543 IncDecOperator operator,
8544 A arg) {
8545 return handleSuperCompounds(
8546 node,
8547 field, CompoundGetter.FIELD,
8548 setter, CompoundSetter.SETTER,
8549 new IncDecCompound(CompoundKind.POSTFIX, operator),
8550 arg);
8551 }
8552
8553
8554 R visitSuperGetterSetterPostfix(
8555 Send node,
8556 FunctionElement getter,
8557 FunctionElement setter,
8558 IncDecOperator operator,
8559 A arg) {
8560 return handleSuperCompounds(
8561 node,
8562 getter, CompoundGetter.GETTER,
8563 setter, CompoundSetter.SETTER,
8564 new IncDecCompound(CompoundKind.POSTFIX, operator),
8565 arg);
8566 }
8567
8568 @override
8569 R visitSuperGetterFieldPostfix(
8570 Send node,
8571 FunctionElement getter,
8572 FieldElement field,
8573 IncDecOperator operator,
8574 A arg) {
8575 return handleSuperCompounds(
8576 node,
8577 getter, CompoundGetter.GETTER,
8578 field, CompoundSetter.FIELD,
8579 new IncDecCompound(CompoundKind.POSTFIX, operator),
8580 arg);
8581 }
8582
8583 @override
8584 R visitSuperMethodSetterPostfix(
8585 Send node,
8586 FunctionElement method,
8587 FunctionElement setter,
8588 IncDecOperator operator,
8589 A arg) {
8590 return handleSuperCompounds(
8591 node,
8592 method, CompoundGetter.METHOD,
8593 setter, CompoundSetter.SETTER,
8594 new IncDecCompound(CompoundKind.POSTFIX, operator),
8595 arg);
8596 }
8597
8598 @override
8599 R visitClassTypeLiteralPostfix(
8600 Send node,
8601 ConstantExpression constant,
8602 IncDecOperator operator,
8603 A arg) {
8604 return handleTypeLiteralConstantCompounds(
8605 node,
8606 constant,
8607 new IncDecCompound(CompoundKind.POSTFIX, operator),
8608 arg);
8609 }
8610
8611 @override
8612 R visitTypedefTypeLiteralPostfix(
8613 Send node,
8614 ConstantExpression constant,
8615 IncDecOperator operator,
8616 A arg) {
8617 return handleTypeLiteralConstantCompounds(
8618 node,
8619 constant,
8620 new IncDecCompound(CompoundKind.POSTFIX, operator),
8621 arg);
8622 }
8623
8624 @override
8625 R visitTypeVariableTypeLiteralPostfix(
8626 Send node,
8627 TypeVariableElement element,
8628 IncDecOperator operator,
8629 A arg) {
8630 return handleTypeVariableTypeLiteralCompounds(
8631 node,
8632 element,
8633 new IncDecCompound(CompoundKind.POSTFIX, operator),
8634 arg);
8635 }
8636
8637 @override
8638 R visitDynamicTypeLiteralPostfix(
8639 Send node,
8640 ConstantExpression constant,
8641 IncDecOperator operator,
8642 A arg) {
8643 return handleTypeLiteralConstantCompounds(
8644 node,
8645 constant,
8646 new IncDecCompound(CompoundKind.POSTFIX, operator),
8647 arg);
8648 }
8649
8650 @override
8651 R visitUnresolvedStaticGetterPostfix(
8652 Send node,
8653 Element element,
8654 MethodElement setter,
8655 IncDecOperator operator,
8656 A arg) {
8657 return handleStaticCompounds(
8658 node,
8659 element,
8660 CompoundGetter.UNRESOLVED,
8661 setter,
8662 CompoundSetter.SETTER,
8663 new IncDecCompound(CompoundKind.POSTFIX, operator),
8664 arg);
8665 }
8666
8667 @override
8668 R visitUnresolvedTopLevelGetterPostfix(
8669 Send node,
8670 Element element,
8671 MethodElement setter,
8672 IncDecOperator operator,
8673 A arg) {
8674 return handleStaticCompounds(
8675 node,
8676 element,
8677 CompoundGetter.UNRESOLVED,
8678 setter,
8679 CompoundSetter.SETTER,
8680 new IncDecCompound(CompoundKind.POSTFIX, operator),
8681 arg);
8682 }
8683
8684 @override
8685 R visitUnresolvedStaticSetterPostfix(
8686 Send node,
8687 MethodElement getter,
8688 Element element,
8689 IncDecOperator operator,
8690 A arg) {
8691 return handleStaticCompounds(
8692 node,
8693 getter,
8694 CompoundGetter.GETTER,
8695 element,
8696 CompoundSetter.INVALID,
8697 new IncDecCompound(CompoundKind.POSTFIX, operator),
8698 arg);
8699 }
8700
8701 @override
8702 R visitUnresolvedTopLevelSetterPostfix(
8703 Send node,
8704 MethodElement getter,
8705 Element element,
8706 IncDecOperator operator,
8707 A arg) {
8708 return handleStaticCompounds(
8709 node,
8710 getter,
8711 CompoundGetter.GETTER,
8712 element,
8713 CompoundSetter.INVALID,
8714 new IncDecCompound(CompoundKind.POSTFIX, operator),
8715 arg);
8716 }
8717
8718 @override
8719 R visitStaticMethodPostfix(
8720 Send node,
8721 MethodElement method,
8722 IncDecOperator operator,
8723 A arg) {
8724 return handleStaticCompounds(
8725 node,
8726 method,
8727 CompoundGetter.METHOD,
8728 method,
8729 CompoundSetter.INVALID,
8730 new IncDecCompound(CompoundKind.POSTFIX, operator),
8731 arg);
8732 }
8733
8734 @override
8735 R visitTopLevelMethodPostfix(
8736 Send node,
8737 MethodElement method,
8738 IncDecOperator operator,
8739 A arg) {
8740 return handleStaticCompounds(
8741 node,
8742 method,
8743 CompoundGetter.METHOD,
8744 method,
8745 CompoundSetter.INVALID,
8746 new IncDecCompound(CompoundKind.POSTFIX, operator),
8747 arg);
8748 }
8749
8750 @override
8751 R visitUnresolvedPostfix(
8752 Send node,
8753 Element element,
8754 IncDecOperator operator,
8755 A arg) {
8756 return handleStaticCompounds(
8757 node,
8758 element,
8759 CompoundGetter.UNRESOLVED,
8760 element,
8761 CompoundSetter.INVALID,
8762 new IncDecCompound(CompoundKind.POSTFIX, operator),
8763 arg);
8764 }
8765
8766 @override
8767 R visitUnresolvedStaticGetterPrefix(
8768 Send node,
8769 Element element,
8770 MethodElement setter,
8771 IncDecOperator operator,
8772 A arg) {
8773 return handleStaticCompounds(
8774 node,
8775 element,
8776 CompoundGetter.UNRESOLVED,
8777 setter,
8778 CompoundSetter.SETTER,
8779 new IncDecCompound(CompoundKind.PREFIX, operator),
8780 arg);
8781 }
8782
8783 @override
8784 R visitUnresolvedTopLevelGetterPrefix(
8785 Send node,
8786 Element element,
8787 MethodElement setter,
8788 IncDecOperator operator,
8789 A arg) {
8790 return handleStaticCompounds(
8791 node,
8792 element,
8793 CompoundGetter.UNRESOLVED,
8794 setter,
8795 CompoundSetter.SETTER,
8796 new IncDecCompound(CompoundKind.PREFIX, operator),
8797 arg);
8798 }
8799
8800 @override
8801 R visitUnresolvedStaticSetterPrefix(
8802 Send node,
8803 MethodElement getter,
8804 Element element,
8805 IncDecOperator operator,
8806 A arg) {
8807 return handleStaticCompounds(
8808 node,
8809 getter,
8810 CompoundGetter.GETTER,
8811 element,
8812 CompoundSetter.INVALID,
8813 new IncDecCompound(CompoundKind.PREFIX, operator),
8814 arg);
8815 }
8816
8817 @override
8818 R visitUnresolvedTopLevelSetterPrefix(
8819 Send node,
8820 MethodElement getter,
8821 Element element,
8822 IncDecOperator operator,
8823 A arg) {
8824 return handleStaticCompounds(
8825 node,
8826 getter,
8827 CompoundGetter.GETTER,
8828 element,
8829 CompoundSetter.INVALID,
8830 new IncDecCompound(CompoundKind.PREFIX, operator),
8831 arg);
8832 }
8833
8834 @override
8835 R visitStaticMethodPrefix(
8836 Send node,
8837 MethodElement method,
8838 IncDecOperator operator,
8839 A arg) {
8840 return handleStaticCompounds(
8841 node,
8842 method,
8843 CompoundGetter.METHOD,
8844 method,
8845 CompoundSetter.INVALID,
8846 new IncDecCompound(CompoundKind.PREFIX, operator),
8847 arg);
8848 }
8849
8850 @override
8851 R visitTopLevelMethodPrefix(
8852 Send node,
8853 MethodElement method,
8854 IncDecOperator operator,
8855 A arg) {
8856 return handleStaticCompounds(
8857 node,
8858 method,
8859 CompoundGetter.METHOD,
8860 method,
8861 CompoundSetter.INVALID,
8862 new IncDecCompound(CompoundKind.PREFIX, operator),
8863 arg);
8864 }
8865
8866 @override
8867 R visitUnresolvedPrefix(
8868 Send node,
8869 Element element,
8870 IncDecOperator operator,
8871 A arg) {
8872 return handleStaticCompounds(
8873 node,
8874 element,
8875 CompoundGetter.UNRESOLVED,
8876 element,
8877 CompoundSetter.INVALID,
8878 new IncDecCompound(CompoundKind.PREFIX, operator),
8879 arg);
8880 }
8881
8882 @override
8883 R visitUnresolvedStaticGetterCompound(
8884 Send node,
8885 Element element,
8886 MethodElement setter,
8887 AssignmentOperator operator,
8888 Node rhs,
8889 A arg) {
8890 return handleStaticCompounds(
8891 node,
8892 element,
8893 CompoundGetter.UNRESOLVED,
8894 setter,
8895 CompoundSetter.SETTER,
8896 new AssignmentCompound(operator, rhs),
8897 arg);
8898 }
8899
8900 @override
8901 R visitUnresolvedTopLevelGetterCompound(
8902 Send node,
8903 Element element,
8904 MethodElement setter,
8905 AssignmentOperator operator,
8906 Node rhs,
8907 A arg) {
8908 return handleStaticCompounds(
8909 node,
8910 element,
8911 CompoundGetter.UNRESOLVED,
8912 setter,
8913 CompoundSetter.SETTER,
8914 new AssignmentCompound(operator, rhs),
8915 arg);
8916 }
8917
8918 @override
8919 R visitUnresolvedStaticSetterCompound(
8920 Send node,
8921 MethodElement getter,
8922 Element element,
8923 AssignmentOperator operator,
8924 Node rhs,
8925 A arg) {
8926 return handleStaticCompounds(
8927 node,
8928 getter,
8929 CompoundGetter.GETTER,
8930 element,
8931 CompoundSetter.INVALID,
8932 new AssignmentCompound(operator, rhs),
8933 arg);
8934 }
8935
8936 @override
8937 R visitUnresolvedTopLevelSetterCompound(
8938 Send node,
8939 MethodElement getter,
8940 Element element,
8941 AssignmentOperator operator,
8942 Node rhs,
8943 A arg) {
8944 return handleStaticCompounds(
8945 node,
8946 getter,
8947 CompoundGetter.GETTER,
8948 element,
8949 CompoundSetter.INVALID,
8950 new AssignmentCompound(operator, rhs),
8951 arg);
8952 }
8953
8954 @override
8955 R visitStaticMethodCompound(
8956 Send node,
8957 MethodElement method,
8958 AssignmentOperator operator,
8959 Node rhs,
8960 A arg) {
8961 return handleStaticCompounds(
8962 node,
8963 method,
8964 CompoundGetter.METHOD,
8965 method,
8966 CompoundSetter.INVALID,
8967 new AssignmentCompound(operator, rhs),
8968 arg);
8969 }
8970
8971 @override
8972 R visitTopLevelMethodCompound(
8973 Send node,
8974 MethodElement method,
8975 AssignmentOperator operator,
8976 Node rhs,
8977 A arg) {
8978 return handleStaticCompounds(
8979 node,
8980 method,
8981 CompoundGetter.METHOD,
8982 method,
8983 CompoundSetter.INVALID,
8984 new AssignmentCompound(operator, rhs),
8985 arg);
8986 }
8987
8988 @override
8989 R visitUnresolvedCompound(
8990 Send node,
8991 Element element,
8992 AssignmentOperator operator,
8993 Node rhs,
8994 A arg) {
8995 return handleStaticCompounds(
8996 node,
8997 element,
8998 CompoundGetter.UNRESOLVED,
8999 element,
9000 CompoundSetter.INVALID,
9001 new AssignmentCompound(operator, rhs),
9002 arg);
9003 }
9004
9005 @override
9006 R visitFinalLocalVariablePostfix(
9007 Send node,
9008 LocalVariableElement variable,
9009 IncDecOperator operator,
9010 A arg) {
9011 return handleLocalCompounds(
9012 node,
9013 variable,
9014 new IncDecCompound(CompoundKind.POSTFIX, operator),
9015 arg,
9016 isSetterValid: false);
9017 }
9018
9019 @override
9020 R visitFinalLocalVariablePrefix(
9021 Send node,
9022 LocalVariableElement variable,
9023 IncDecOperator operator,
9024 A arg) {
9025 return handleLocalCompounds(
9026 node,
9027 variable,
9028 new IncDecCompound(CompoundKind.PREFIX, operator),
9029 arg,
9030 isSetterValid: false);
9031 }
9032
9033 @override
9034 R visitFinalParameterPostfix(
9035 Send node,
9036 ParameterElement parameter,
9037 IncDecOperator operator,
9038 A arg) {
9039 return handleLocalCompounds(
9040 node,
9041 parameter,
9042 new IncDecCompound(CompoundKind.POSTFIX, operator),
9043 arg,
9044 isSetterValid: false);
9045 }
9046
9047 @override
9048 R visitFinalParameterPrefix(
9049 Send node,
9050 ParameterElement parameter,
9051 IncDecOperator operator,
9052 A arg) {
9053 return handleLocalCompounds(
9054 node,
9055 parameter,
9056 new IncDecCompound(CompoundKind.PREFIX, operator),
9057 arg,
9058 isSetterValid: false);
9059 }
9060
9061 @override
9062 R visitFinalStaticFieldPostfix(
9063 Send node,
9064 FieldElement field,
9065 IncDecOperator operator,
9066 A arg) {
9067 return handleStaticCompounds(
9068 node,
9069 field,
9070 CompoundGetter.FIELD,
9071 field,
9072 CompoundSetter.INVALID,
9073 new IncDecCompound(CompoundKind.POSTFIX, operator),
9074 arg);
9075 }
9076
9077 @override
9078 R visitFinalStaticFieldPrefix(
9079 Send node,
9080 FieldElement field,
9081 IncDecOperator operator,
9082 A arg) {
9083 return handleStaticCompounds(
9084 node,
9085 field,
9086 CompoundGetter.FIELD,
9087 field,
9088 CompoundSetter.INVALID,
9089 new IncDecCompound(CompoundKind.PREFIX, operator),
9090 arg);
9091 }
9092
9093 @override
9094 R visitSuperFieldFieldCompound(
9095 Send node,
9096 FieldElement readField,
9097 FieldElement writtenField,
9098 AssignmentOperator operator,
9099 Node rhs,
9100 A arg) {
9101 return handleSuperCompounds(
9102 node,
9103 readField,
9104 CompoundGetter.FIELD,
9105 writtenField,
9106 CompoundSetter.FIELD,
9107 new AssignmentCompound(operator, rhs),
9108 arg);
9109 }
9110
9111 @override
9112 R visitFinalSuperFieldPostfix(
9113 Send node,
9114 FieldElement field,
9115 IncDecOperator operator,
9116 A arg) {
9117 return handleSuperCompounds(
9118 node,
9119 field,
9120 CompoundGetter.FIELD,
9121 field,
9122 CompoundSetter.INVALID,
9123 new IncDecCompound(CompoundKind.POSTFIX, operator),
9124 arg);
9125 }
9126
9127 @override
9128 R visitFinalSuperFieldPrefix(
9129 Send node,
9130 FieldElement field,
9131 IncDecOperator operator,
9132 A arg) {
9133 return handleSuperCompounds(
9134 node,
9135 field,
9136 CompoundGetter.FIELD,
9137 field,
9138 CompoundSetter.INVALID,
9139 new IncDecCompound(CompoundKind.PREFIX, operator),
9140 arg);
9141 }
9142
9143 @override
9144 R visitSuperMethodCompound(
9145 Send node,
9146 FunctionElement method,
9147 AssignmentOperator operator,
9148 Node rhs,
9149 A arg) {
9150 return handleSuperCompounds(
9151 node,
9152 method,
9153 CompoundGetter.METHOD,
9154 method,
9155 CompoundSetter.INVALID,
9156 new AssignmentCompound(operator, rhs),
9157 arg);
9158 }
9159
9160 @override
9161 R visitSuperMethodPostfix(
9162 Send node,
9163 FunctionElement method,
9164 IncDecOperator operator,
9165 A arg) {
9166 return handleSuperCompounds(
9167 node,
9168 method,
9169 CompoundGetter.METHOD,
9170 method,
9171 CompoundSetter.INVALID,
9172 new IncDecCompound(CompoundKind.POSTFIX, operator),
9173 arg);
9174 }
9175
9176 @override
9177 R visitSuperMethodPrefix(
9178 Send node,
9179 FunctionElement method,
9180 IncDecOperator operator,
9181 A arg) {
9182 return handleSuperCompounds(
9183 node,
9184 method,
9185 CompoundGetter.METHOD,
9186 method,
9187 CompoundSetter.INVALID,
9188 new IncDecCompound(CompoundKind.PREFIX, operator),
9189 arg);
9190 }
9191
9192 @override
9193 R visitFinalTopLevelFieldPostfix(
9194 Send node,
9195 FieldElement field,
9196 IncDecOperator operator,
9197 A arg) {
9198 return handleStaticCompounds(
9199 node,
9200 field,
9201 CompoundGetter.FIELD,
9202 field,
9203 CompoundSetter.INVALID,
9204 new IncDecCompound(CompoundKind.POSTFIX, operator),
9205 arg);
9206 }
9207
9208 @override
9209 R visitFinalTopLevelFieldPrefix(
9210 Send node,
9211 FieldElement field,
9212 IncDecOperator operator,
9213 A arg) {
9214 return handleStaticCompounds(
9215 node,
9216 field,
9217 CompoundGetter.FIELD,
9218 field,
9219 CompoundSetter.INVALID,
9220 new IncDecCompound(CompoundKind.PREFIX, operator),
9221 arg);
9222 }
9223
9224 @override
9225 R visitUnresolvedSuperCompound(
9226 Send node,
9227 Element element,
9228 AssignmentOperator operator,
9229 Node rhs,
9230 A arg) {
9231 return handleSuperCompounds(
9232 node,
9233 element,
9234 CompoundGetter.UNRESOLVED,
9235 element,
9236 CompoundSetter.INVALID,
9237 new AssignmentCompound(operator, rhs),
9238 arg);
9239 }
9240
9241 @override
9242 R visitUnresolvedSuperPostfix(
9243 Send node,
9244 Element element,
9245 IncDecOperator operator,
9246 A arg) {
9247 return handleSuperCompounds(
9248 node,
9249 element,
9250 CompoundGetter.UNRESOLVED,
9251 element,
9252 CompoundSetter.INVALID,
9253 new IncDecCompound(CompoundKind.POSTFIX, operator),
9254 arg);
9255 }
9256
9257 @override
9258 R visitUnresolvedSuperPrefix(
9259 Send node,
9260 Element element,
9261 IncDecOperator operator,
9262 A arg) {
9263 return handleSuperCompounds(
9264 node,
9265 element,
9266 CompoundGetter.UNRESOLVED,
9267 element,
9268 CompoundSetter.INVALID,
9269 new IncDecCompound(CompoundKind.PREFIX, operator),
9270 arg);
9271 }
9272
9273 @override
9274 R visitUnresolvedSuperGetterCompound(
9275 Send node, Element element,
9276 MethodElement setter,
9277 AssignmentOperator operator,
9278 Node rhs,
9279 A arg) {
9280 return handleSuperCompounds(
9281 node,
9282 element,
9283 CompoundGetter.UNRESOLVED,
9284 setter,
9285 CompoundSetter.SETTER,
9286 new AssignmentCompound(operator, rhs),
9287 arg);
9288 }
9289
9290 @override
9291 R visitUnresolvedSuperGetterPostfix(
9292 Send node,
9293 Element element,
9294 MethodElement setter,
9295 IncDecOperator operator,
9296 A arg) {
9297 return handleSuperCompounds(
9298 node,
9299 element,
9300 CompoundGetter.UNRESOLVED,
9301 setter,
9302 CompoundSetter.SETTER,
9303 new IncDecCompound(CompoundKind.POSTFIX, operator),
9304 arg);
9305 }
9306
9307 @override
9308 R visitUnresolvedSuperGetterPrefix(
9309 Send node,
9310 Element element,
9311 MethodElement setter,
9312 IncDecOperator operator,
9313 A arg) {
9314 return handleSuperCompounds(
9315 node,
9316 element,
9317 CompoundGetter.UNRESOLVED,
9318 setter,
9319 CompoundSetter.SETTER,
9320 new IncDecCompound(CompoundKind.PREFIX, operator),
9321 arg);
9322 }
9323
9324 @override
9325 R visitUnresolvedSuperSetterCompound(
9326 Send node,
9327 MethodElement getter,
9328 Element element,
9329 AssignmentOperator operator,
9330 Node rhs,
9331 A arg) {
9332 return handleSuperCompounds(
9333 node,
9334 getter,
9335 CompoundGetter.GETTER,
9336 element,
9337 CompoundSetter.INVALID,
9338 new AssignmentCompound(operator, rhs),
9339 arg);
9340 }
9341
9342 @override
9343 R visitUnresolvedSuperSetterPostfix(
9344 Send node,
9345 MethodElement getter,
9346 Element element,
9347 IncDecOperator operator,
9348 A arg) {
9349 return handleSuperCompounds(
9350 node,
9351 getter,
9352 CompoundGetter.GETTER,
9353 element,
9354 CompoundSetter.INVALID,
9355 new IncDecCompound(CompoundKind.POSTFIX, operator),
9356 arg);
9357 }
9358
9359 @override
9360 R visitUnresolvedSuperSetterPrefix(
9361 Send node,
9362 MethodElement getter,
9363 Element element,
9364 IncDecOperator operator,
9365 A arg) {
9366 return handleSuperCompounds(
9367 node,
9368 getter,
9369 CompoundGetter.GETTER,
9370 element,
9371 CompoundSetter.INVALID,
9372 new IncDecCompound(CompoundKind.PREFIX, operator),
9373 arg);
9374 }
9375 }
9376
9377 /// Simplified handling of indexed compound assignments and prefix/postfix
9378 /// expressions.
9379 abstract class BaseImplementationOfIndexCompoundsMixin<R, A>
9380 implements SemanticSendVisitor<R, A> {
9381
9382 /// Handle a dynamic index compounds, like `receiver[index] += rhs` or
9383 /// `--receiver[index]`.
9384 R handleIndexCompounds(
9385 SendSet node,
9386 Node receiver,
9387 Node index,
9388 CompoundRhs rhs,
9389 A arg);
9390
9391 /// Handle a super index compounds, like `super[index] += rhs` or
9392 /// `--super[index]`.
9393 R handleSuperIndexCompounds(
9394 SendSet node,
9395 Element indexFunction,
9396 Element indexSetFunction,
9397 Node index,
9398 CompoundRhs rhs,
9399 A arg,
9400 {bool isGetterValid,
9401 bool isSetterValid});
9402
9403 @override
9404 R visitSuperCompoundIndexSet(
9405 Send node,
9406 FunctionElement indexFunction,
9407 FunctionElement indexSetFunction,
9408 Node index,
9409 AssignmentOperator operator,
9410 Node rhs,
9411 A arg) {
9412 return handleSuperIndexCompounds(
9413 node, indexFunction, indexSetFunction, index,
9414 new AssignmentCompound(operator, rhs), arg,
9415 isGetterValid: true, isSetterValid: true);
9416 }
9417
9418 @override
9419 R visitSuperIndexPostfix(
9420 Send node,
9421 FunctionElement indexFunction,
9422 FunctionElement indexSetFunction,
9423 Node index,
9424 IncDecOperator operator,
9425 A arg) {
9426 return handleSuperIndexCompounds(
9427 node, indexFunction, indexSetFunction, index,
9428 new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
9429 isGetterValid: true, isSetterValid: true);
9430 }
9431
9432 @override
9433 R visitSuperIndexPrefix(
9434 Send node,
9435 FunctionElement indexFunction,
9436 FunctionElement indexSetFunction,
9437 Node index,
9438 IncDecOperator operator,
9439 A arg) {
9440 return handleSuperIndexCompounds(
9441 node, indexFunction, indexSetFunction, index,
9442 new IncDecCompound(CompoundKind.PREFIX, operator), arg,
9443 isGetterValid: true, isSetterValid: true);
9444 }
9445
9446 @override
9447 R visitUnresolvedSuperGetterCompoundIndexSet(
9448 Send node,
9449 Element indexFunction,
9450 FunctionElement indexSetFunction,
9451 Node index,
9452 AssignmentOperator operator,
9453 Node rhs,
9454 A arg) {
9455 return handleSuperIndexCompounds(
9456 node, indexFunction, indexSetFunction, index,
9457 new AssignmentCompound(operator, rhs), arg,
9458 isGetterValid: false, isSetterValid: true);
9459 }
9460
9461 @override
9462 R visitUnresolvedSuperSetterCompoundIndexSet(
9463 Send node,
9464 FunctionElement indexFunction,
9465 Element indexSetFunction,
9466 Node index,
9467 AssignmentOperator operator,
9468 Node rhs,
9469 A arg) {
9470 return handleSuperIndexCompounds(
9471 node, indexFunction, indexSetFunction, index,
9472 new AssignmentCompound(operator, rhs), arg,
9473 isGetterValid: true, isSetterValid: false);
9474 }
9475
9476 @override
9477 R visitUnresolvedSuperCompoundIndexSet(
9478 Send node,
9479 Element element,
9480 Node index,
9481 AssignmentOperator operator,
9482 Node rhs,
9483 A arg) {
9484 return handleSuperIndexCompounds(
9485 node, element, element, index,
9486 new AssignmentCompound(operator, rhs), arg,
9487 isGetterValid: false, isSetterValid: false);
9488 }
9489
9490 @override
9491 R visitUnresolvedSuperGetterIndexPostfix(
9492 Send node,
9493 Element element,
9494 FunctionElement indexSetFunction,
9495 Node index,
9496 IncDecOperator operator,
9497 A arg) {
9498 return handleSuperIndexCompounds(
9499 node, element, indexSetFunction, index,
9500 new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
9501 isGetterValid: false, isSetterValid: true);
9502 }
9503
9504 @override
9505 R visitUnresolvedSuperGetterIndexPrefix(
9506 Send node,
9507 Element element,
9508 FunctionElement indexSetFunction,
9509 Node index,
9510 IncDecOperator operator,
9511 A arg) {
9512 return handleSuperIndexCompounds(
9513 node, element, indexSetFunction, index,
9514 new IncDecCompound(CompoundKind.PREFIX, operator), arg,
9515 isGetterValid: false, isSetterValid: true);
9516 }
9517
9518 @override
9519 R visitUnresolvedSuperSetterIndexPostfix(
9520 Send node,
9521 MethodElement indexFunction,
9522 Element element,
9523 Node index,
9524 IncDecOperator operator,
9525 A arg) {
9526 return handleSuperIndexCompounds(
9527 node, indexFunction, element, index,
9528 new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
9529 isGetterValid: true, isSetterValid: false);
9530 }
9531
9532 @override
9533 R visitUnresolvedSuperSetterIndexPrefix(
9534 Send node,
9535 MethodElement indexFunction,
9536 Element element,
9537 Node index,
9538 IncDecOperator operator,
9539 A arg) {
9540 return handleSuperIndexCompounds(
9541 node, indexFunction, element, index,
9542 new IncDecCompound(CompoundKind.PREFIX, operator), arg,
9543 isGetterValid: true, isSetterValid: false);
9544 }
9545
9546 @override
9547 R visitUnresolvedSuperIndexPostfix(
9548 Send node,
9549 Element element,
9550 Node index,
9551 IncDecOperator operator,
9552 A arg) {
9553 return handleSuperIndexCompounds(
9554 node, element, element, index,
9555 new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
9556 isGetterValid: false, isSetterValid: false);
9557 }
9558
9559 @override
9560 R visitUnresolvedSuperIndexPrefix(
9561 Send node,
9562 Element element,
9563 Node index,
9564 IncDecOperator operator,
9565 A arg) {
9566 return handleSuperIndexCompounds(
9567 node, element, element, index,
9568 new IncDecCompound(CompoundKind.PREFIX, operator), arg,
9569 isGetterValid: false, isSetterValid: false);
9570 }
9571
9572 @override
9573 R visitCompoundIndexSet(
9574 SendSet node,
9575 Node receiver,
9576 Node index,
9577 AssignmentOperator operator,
9578 Node rhs,
9579 A arg) {
9580 return handleIndexCompounds(
9581 node, receiver, index,
9582 new AssignmentCompound(operator, rhs), arg);
9583 }
9584
9585 @override
9586 R visitIndexPostfix( 6398 R visitIndexPostfix(
9587 Send node, 6399 Send node,
9588 Node receiver, 6400 Node receiver,
9589 Node index, 6401 Node index,
9590 IncDecOperator operator, 6402 IncDecOperator operator,
9591 A arg) { 6403 A arg) {
9592 return handleIndexCompounds( 6404 return handleDynamicIndexPostfixPrefix(
9593 node, receiver, index, 6405 node, receiver, index, operator, arg, isPrefix: false);
9594 new IncDecCompound(CompoundKind.POSTFIX, operator), arg);
9595 } 6406 }
9596 6407
9597 @override 6408 @override
9598 R visitIndexPrefix( 6409 R visitIndexPrefix(
9599 Send node, 6410 Send node,
9600 Node receiver, 6411 Node receiver,
9601 Node index, 6412 Node index,
9602 IncDecOperator operator, 6413 IncDecOperator operator,
9603 A arg) { 6414 A arg) {
9604 return handleIndexCompounds( 6415 return handleDynamicIndexPostfixPrefix(
9605 node, receiver, index, 6416 node, receiver, index, operator, arg, isPrefix: true);
9606 new IncDecCompound(CompoundKind.PREFIX, operator), arg);
9607 } 6417 }
9608 } 6418 }
9609 6419
9610
9611
9612 /// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by 6420 /// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by
9613 /// delegating calls to `handleSuperXPostfixPrefix` methods. 6421 /// delegating calls to `handleSuperXPostfixPrefix` methods.
9614 /// 6422 ///
9615 /// This mixin is useful for the cases where super prefix/postfix expression are 6423 /// This mixin is useful for the cases where super prefix/postfix expression are
9616 /// handled uniformly. 6424 /// handled uniformly.
9617 abstract class BaseImplementationOfSuperIncDecsMixin<R, A> 6425 abstract class BaseImplementationOfSuperIncDecsMixin<R, A>
9618 implements SemanticSendVisitor<R, A> { 6426 implements SemanticSendVisitor<R, A> {
9619 R handleSuperFieldFieldPostfixPrefix( 6427 R handleSuperFieldFieldPostfixPrefix(
9620 Send node, 6428 Send node,
9621 FieldElement readField, 6429 FieldElement readField,
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
9661 FunctionElement indexFunction, 6469 FunctionElement indexFunction,
9662 FunctionElement indexSetFunction, 6470 FunctionElement indexSetFunction,
9663 Node index, 6471 Node index,
9664 IncDecOperator operator, 6472 IncDecOperator operator,
9665 A arg, 6473 A arg,
9666 {bool isPrefix}); 6474 {bool isPrefix});
9667 6475
9668 R handleUnresolvedSuperGetterIndexPostfixPrefix( 6476 R handleUnresolvedSuperGetterIndexPostfixPrefix(
9669 Send node, 6477 Send node,
9670 Element element, 6478 Element element,
9671 MethodElement setter,
9672 Node index, 6479 Node index,
9673 IncDecOperator operator, 6480 IncDecOperator operator,
9674 A arg, 6481 A arg,
9675 {bool isPrefix}); 6482 {bool isPrefix});
9676 6483
9677 R handleUnresolvedSuperSetterIndexPostfixPrefix( 6484 R handleUnresolvedSuperSetterIndexPostfixPrefix(
9678 Send node, 6485 Send node,
9679 FunctionElement indexFunction, 6486 FunctionElement indexFunction,
9680 Element element, 6487 Element element,
9681 Node index, 6488 Node index,
9682 IncDecOperator operator, 6489 IncDecOperator operator,
9683 A arg, 6490 A arg,
9684 {bool isPrefix}); 6491 {bool isPrefix});
9685 6492
9686 R handleUnresolvedSuperIndexPostfixPrefix(
9687 Send node,
9688 Element element,
9689 Node index,
9690 IncDecOperator operator,
9691 A arg,
9692 {bool isPrefix});
9693
9694 R handleFinalSuperFieldPostfixPrefix(
9695 Send node,
9696 FieldElement field,
9697 IncDecOperator operator,
9698 A arg,
9699 {bool isPrefix});
9700
9701 R handleSuperMethodPostfixPrefix(
9702 Send node,
9703 MethodElement method,
9704 IncDecOperator operator,
9705 A arg,
9706 {bool isPrefix});
9707
9708 R handleUnresolvedSuperPostfixPrefix(
9709 Send node,
9710 Element element,
9711 IncDecOperator operator,
9712 A arg,
9713 {bool isPrefix});
9714
9715 R handleUnresolvedSuperGetterPostfixPrefix(
9716 Send node,
9717 Element element,
9718 MethodElement setter,
9719 IncDecOperator operator,
9720 A arg,
9721 {bool isPrefix});
9722
9723 R handleUnresolvedSuperSetterPostfixPrefix(
9724 Send node,
9725 MethodElement getter,
9726 Element element,
9727 IncDecOperator operator,
9728 A arg,
9729 {bool isPrefix});
9730
9731 @override 6493 @override
9732 R visitSuperFieldFieldPostfix( 6494 R visitSuperFieldFieldPostfix(
9733 Send node, 6495 Send node,
9734 FieldElement readField, 6496 FieldElement readField,
9735 FieldElement writtenField, 6497 FieldElement writtenField,
9736 IncDecOperator operator, 6498 IncDecOperator operator,
9737 A arg) { 6499 A arg) {
9738 return handleSuperFieldFieldPostfixPrefix( 6500 return handleSuperFieldFieldPostfixPrefix(
9739 node, readField, writtenField, operator, arg, isPrefix: false); 6501 node, readField, writtenField, operator, arg, isPrefix: false);
9740 } 6502 }
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after
9881 A arg) { 6643 A arg) {
9882 return handleSuperIndexPostfixPrefix( 6644 return handleSuperIndexPostfixPrefix(
9883 node, indexFunction, indexSetFunction, 6645 node, indexFunction, indexSetFunction,
9884 index, operator, arg, isPrefix: true); 6646 index, operator, arg, isPrefix: true);
9885 } 6647 }
9886 6648
9887 @override 6649 @override
9888 R visitUnresolvedSuperGetterIndexPostfix( 6650 R visitUnresolvedSuperGetterIndexPostfix(
9889 Send node, 6651 Send node,
9890 Element element, 6652 Element element,
9891 MethodElement setter,
9892 Node index, 6653 Node index,
9893 IncDecOperator operator, 6654 IncDecOperator operator,
9894 A arg) { 6655 A arg) {
9895 return handleUnresolvedSuperGetterIndexPostfixPrefix( 6656 return handleUnresolvedSuperGetterIndexPostfixPrefix(
9896 node, element, setter, index, operator, arg, isPrefix: false); 6657 node, element, index, operator, arg, isPrefix: false);
9897 } 6658 }
9898 6659
9899 @override 6660 @override
9900 R visitUnresolvedSuperGetterIndexPrefix( 6661 R visitUnresolvedSuperGetterIndexPrefix(
9901 Send node, 6662 Send node,
9902 Element element, 6663 Element element,
9903 MethodElement setter,
9904 Node index, 6664 Node index,
9905 IncDecOperator operator, 6665 IncDecOperator operator,
9906 A arg) { 6666 A arg) {
9907 return handleUnresolvedSuperGetterIndexPostfixPrefix( 6667 return handleUnresolvedSuperGetterIndexPostfixPrefix(
9908 node, element, setter, index, operator, arg, isPrefix: true); 6668 node, element, index, operator, arg, isPrefix: true);
9909 } 6669 }
9910 6670
9911 @override 6671 @override
9912 R visitUnresolvedSuperSetterIndexPostfix( 6672 R visitUnresolvedSuperSetterIndexPostfix(
9913 Send node, 6673 Send node,
9914 MethodElement indexFunction, 6674 MethodElement indexFunction,
9915 Element element, 6675 Element element,
9916 Node index, 6676 Node index,
9917 IncDecOperator operator, 6677 IncDecOperator operator,
9918 A arg) { 6678 A arg) {
9919 return handleUnresolvedSuperSetterIndexPostfixPrefix( 6679 return handleUnresolvedSuperSetterIndexPostfixPrefix(
9920 node, indexFunction, element, index, operator, arg, isPrefix: false); 6680 node, indexFunction, element, index, operator, arg, isPrefix: false);
9921 } 6681 }
9922 6682
9923 @override 6683 @override
9924 R visitUnresolvedSuperSetterIndexPrefix( 6684 R visitUnresolvedSuperSetterIndexPrefix(
9925 Send node, 6685 Send node,
9926 MethodElement indexFunction, 6686 MethodElement indexFunction,
9927 Element element, 6687 Element element,
9928 Node index, 6688 Node index,
9929 IncDecOperator operator, 6689 IncDecOperator operator,
9930 A arg) { 6690 A arg) {
9931 return handleUnresolvedSuperSetterIndexPostfixPrefix( 6691 return handleUnresolvedSuperSetterIndexPostfixPrefix(
9932 node, indexFunction, element, index, operator, arg, isPrefix: true); 6692 node, indexFunction, element, index, operator, arg, isPrefix: true);
9933 } 6693 }
9934
9935 @override
9936 R visitUnresolvedSuperIndexPostfix(
9937 Send node,
9938 Element element,
9939 Node index,
9940 IncDecOperator operator,
9941 A arg) {
9942 return handleUnresolvedSuperIndexPostfixPrefix(
9943 node, element, index, operator, arg, isPrefix: false);
9944 }
9945
9946 @override
9947 R visitUnresolvedSuperIndexPrefix(
9948 Send node,
9949 Element element,
9950 Node index,
9951 IncDecOperator operator,
9952 A arg) {
9953 return handleUnresolvedSuperIndexPostfixPrefix(
9954 node, element, index, operator, arg, isPrefix: true);
9955 }
9956
9957 @override
9958 R visitFinalSuperFieldPostfix(
9959 Send node,
9960 FieldElement field,
9961 IncDecOperator operator,
9962 A arg) {
9963 return handleFinalSuperFieldPostfixPrefix(
9964 node, field, operator, arg, isPrefix: false);
9965 }
9966
9967 @override
9968 R visitFinalSuperFieldPrefix(
9969 Send node,
9970 FieldElement field,
9971 IncDecOperator operator,
9972 A arg) {
9973 return handleFinalSuperFieldPostfixPrefix(
9974 node, field, operator, arg, isPrefix: true);
9975 }
9976
9977 @override
9978 R visitSuperMethodPostfix(
9979 Send node,
9980 MethodElement method,
9981 IncDecOperator operator,
9982 A arg) {
9983 return handleSuperMethodPostfixPrefix(
9984 node, method, operator, arg, isPrefix: false);
9985 }
9986
9987 @override
9988 R visitSuperMethodPrefix(
9989 Send node,
9990 MethodElement method,
9991 IncDecOperator operator,
9992 A arg) {
9993 return handleSuperMethodPostfixPrefix(
9994 node, method, operator, arg, isPrefix: true);
9995 }
9996
9997 @override
9998 R visitUnresolvedSuperPostfix(
9999 Send node,
10000 Element element,
10001 IncDecOperator operator,
10002 A arg) {
10003 return handleUnresolvedSuperPostfixPrefix(
10004 node, element, operator, arg, isPrefix: false);
10005 }
10006
10007 @override
10008 R visitUnresolvedSuperPrefix(
10009 Send node,
10010 Element element,
10011 IncDecOperator operator,
10012 A arg) {
10013 return handleUnresolvedSuperPostfixPrefix(
10014 node, element, operator, arg, isPrefix: true);
10015 }
10016
10017 @override
10018 R visitUnresolvedSuperGetterPostfix(
10019 Send node,
10020 Element element,
10021 MethodElement setter,
10022 IncDecOperator operator,
10023 A arg) {
10024 return handleUnresolvedSuperGetterPostfixPrefix(
10025 node, element, setter, operator, arg, isPrefix: false);
10026 }
10027
10028 @override
10029 R visitUnresolvedSuperGetterPrefix(
10030 Send node,
10031 Element element,
10032 MethodElement setter,
10033 IncDecOperator operator,
10034 A arg) {
10035 return handleUnresolvedSuperGetterPostfixPrefix(
10036 node, element, setter, operator, arg, isPrefix: true);
10037 }
10038
10039 @override
10040 R visitUnresolvedSuperSetterPostfix(
10041 Send node,
10042 MethodElement getter,
10043 Element element,
10044 IncDecOperator operator,
10045 A arg) {
10046 return handleUnresolvedSuperSetterPostfixPrefix(
10047 node, getter, element, operator, arg, isPrefix: false);
10048 }
10049
10050 @override
10051 R visitUnresolvedSuperSetterPrefix(
10052 Send node,
10053 MethodElement getter,
10054 Element element,
10055 IncDecOperator operator,
10056 A arg) {
10057 return handleUnresolvedSuperSetterPostfixPrefix(
10058 node, getter, element, operator, arg, isPrefix: true);
10059 }
10060 } 6694 }
10061 6695
10062 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by 6696 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by
10063 /// delegating calls to the `handleConstructorInvoke` method. 6697 /// delegating calls to the `handleConstructorInvoke` method.
10064 /// 6698 ///
10065 /// This mixin is useful for the cases where all constructor invocations are 6699 /// This mixin is useful for the cases where all constructor invocations are
10066 /// handled uniformly. 6700 /// handled uniformly.
10067 abstract class BaseImplementationOfNewMixin<R, A> 6701 abstract class BaseImplementationOfNewMixin<R, A>
10068 implements SemanticSendVisitor<R, A> { 6702 implements SemanticSendVisitor<R, A> {
10069 6703
10070 R handleConstructorInvoke( 6704 R handleConstructorInvoke(
10071 NewExpression node, 6705 NewExpression node,
10072 ConstructorElement constructor, 6706 ConstructorElement constructor,
10073 DartType type, 6707 DartType type,
10074 NodeList arguments, 6708 NodeList arguments,
10075 CallStructure callStructure, 6709 CallStructure callStructure,
10076 A arg); 6710 A arg);
10077 6711
10078 R visitGenerativeConstructorInvoke( 6712 R visitGenerativeConstructorInvoke(
10079 NewExpression node, 6713 NewExpression node,
10080 ConstructorElement constructor, 6714 ConstructorElement constructor,
10081 InterfaceType type, 6715 InterfaceType type,
10082 NodeList arguments, 6716 NodeList arguments,
10083 CallStructure callStructure, 6717 CallStructure callStructure,
10084 A arg) { 6718 A arg) {
10085 return handleConstructorInvoke( 6719 return handleConstructorInvoke(
10086 node, constructor, type, arguments, callStructure, arg); 6720 node, constructor, type, arguments, callStructure, arg);
10087 } 6721 }
10088 6722
10089 @override
10090 R visitRedirectingGenerativeConstructorInvoke( 6723 R visitRedirectingGenerativeConstructorInvoke(
10091 NewExpression node, 6724 NewExpression node,
10092 ConstructorElement constructor, 6725 ConstructorElement constructor,
10093 InterfaceType type, 6726 InterfaceType type,
10094 NodeList arguments, 6727 NodeList arguments,
10095 CallStructure callStructure, 6728 CallStructure callStructure,
10096 A arg) { 6729 A arg) {
10097 return handleConstructorInvoke( 6730 return handleConstructorInvoke(
10098 node, constructor, type, arguments, callStructure, arg); 6731 node, constructor, type, arguments, callStructure, arg);
10099 } 6732 }
10100 6733
10101 @override
10102 R visitFactoryConstructorInvoke( 6734 R visitFactoryConstructorInvoke(
10103 NewExpression node, 6735 NewExpression node,
10104 ConstructorElement constructor, 6736 ConstructorElement constructor,
10105 InterfaceType type, 6737 InterfaceType type,
10106 NodeList arguments, 6738 NodeList arguments,
10107 CallStructure callStructure, 6739 CallStructure callStructure,
10108 A arg) { 6740 A arg) {
10109 return handleConstructorInvoke( 6741 return handleConstructorInvoke(
10110 node, constructor, type, arguments, callStructure, arg); 6742 node, constructor, type, arguments, callStructure, arg);
10111 } 6743 }
10112 6744
10113 @override
10114 R visitRedirectingFactoryConstructorInvoke( 6745 R visitRedirectingFactoryConstructorInvoke(
10115 NewExpression node, 6746 NewExpression node,
10116 ConstructorElement constructor, 6747 ConstructorElement constructor,
10117 InterfaceType type, 6748 InterfaceType type,
10118 ConstructorElement effectiveTarget, 6749 ConstructorElement effectiveTarget,
10119 InterfaceType effectiveTargetType, 6750 InterfaceType effectiveTargetType,
10120 NodeList arguments, 6751 NodeList arguments,
10121 CallStructure callStructure, 6752 CallStructure callStructure,
10122 A arg) { 6753 A arg) {
10123 return handleConstructorInvoke( 6754 return handleConstructorInvoke(
10124 node, constructor, type, arguments, callStructure, arg); 6755 node, constructor, type, arguments, callStructure, arg);
10125 } 6756 }
10126 6757
10127 @override
10128 R visitUnresolvedConstructorInvoke( 6758 R visitUnresolvedConstructorInvoke(
10129 NewExpression node, 6759 NewExpression node,
10130 Element constructor, 6760 Element constructor,
10131 DartType type, 6761 DartType type,
10132 NodeList arguments, 6762 NodeList arguments,
10133 Selector selector, 6763 Selector selector,
10134 A arg) { 6764 A arg) {
10135 return handleConstructorInvoke( 6765 return handleConstructorInvoke(
10136 node, constructor, type, arguments, selector.callStructure, arg); 6766 node, constructor, type, arguments, selector.callStructure, arg);
10137 } 6767 }
10138 6768
10139 @override
10140 R visitUnresolvedClassConstructorInvoke( 6769 R visitUnresolvedClassConstructorInvoke(
10141 NewExpression node, 6770 NewExpression node,
10142 Element element, 6771 Element element,
10143 DartType type, 6772 DartType type,
10144 NodeList arguments, 6773 NodeList arguments,
10145 Selector selector, 6774 Selector selector,
10146 A arg) { 6775 A arg) {
10147 return handleConstructorInvoke( 6776 return handleConstructorInvoke(
10148 node, element, type, arguments, selector.callStructure, arg); 6777 node, element, type, arguments, selector.callStructure, arg);
10149 } 6778 }
10150 6779
10151 @override
10152 R visitAbstractClassConstructorInvoke( 6780 R visitAbstractClassConstructorInvoke(
10153 NewExpression node, 6781 NewExpression node,
10154 ConstructorElement constructor, 6782 ConstructorElement constructor,
10155 InterfaceType type, 6783 InterfaceType type,
10156 NodeList arguments, 6784 NodeList arguments,
10157 CallStructure callStructure, 6785 CallStructure callStructure,
10158 A arg) { 6786 A arg) {
10159 return handleConstructorInvoke( 6787 return handleConstructorInvoke(
10160 node, constructor, type, arguments, callStructure, arg); 6788 node, constructor, type, arguments, callStructure, arg);
10161 } 6789 }
10162
10163 @override
10164 R visitUnresolvedRedirectingFactoryConstructorInvoke( 6790 R visitUnresolvedRedirectingFactoryConstructorInvoke(
10165 NewExpression node, 6791 NewExpression node,
10166 ConstructorElement constructor, 6792 ConstructorElement constructor,
10167 InterfaceType type, 6793 InterfaceType type,
10168 NodeList arguments, 6794 NodeList arguments,
10169 CallStructure callStructure, 6795 CallStructure callStructure,
10170 A arg) { 6796 A arg) {
10171 return handleConstructorInvoke( 6797 return handleConstructorInvoke(
10172 node, constructor, type, arguments, callStructure, arg); 6798 node, constructor, type, arguments, callStructure, arg);
10173 } 6799 }
10174 } 6800 }
OLDNEW
« no previous file with comments | « pkg/compiler/lib/src/resolution/semantic_visitor.dart ('k') | pkg/compiler/lib/src/resolution/send_resolver.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698