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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 1126173002: Refactor handling of compounds. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Update status. 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 | Annotate | Revision Log
« 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
64 R errorClassTypeLiteralSet( 36 R errorClassTypeLiteralSet(
65 SendSet node, 37 SendSet node,
66 ConstantExpression constant, 38 ConstantExpression constant,
67 Node rhs, 39 Node rhs,
68 A arg) { 40 A arg) {
69 return bulkHandleError(node, arg); 41 return bulkHandleError(node, arg);
70 } 42 }
71 43
72 @override 44 @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
101 R errorDynamicTypeLiteralSet( 45 R errorDynamicTypeLiteralSet(
102 SendSet node, 46 SendSet node,
103 ConstantExpression constant, 47 ConstantExpression constant,
104 Node rhs, 48 Node rhs,
105 A arg) { 49 A arg) {
106 return bulkHandleError(node, arg); 50 return bulkHandleError(node, arg);
107 } 51 }
108 52
109 @override 53 @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
121 R errorFinalLocalVariableSet( 54 R errorFinalLocalVariableSet(
122 SendSet node, 55 SendSet node,
123 LocalVariableElement variable, 56 LocalVariableElement variable,
124 Node rhs, 57 Node rhs,
125 A arg) { 58 A arg) {
126 return bulkHandleError(node, arg); 59 return bulkHandleError(node, arg);
127 } 60 }
128 61
129 @override 62 @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
140 R errorFinalParameterSet( 63 R errorFinalParameterSet(
141 SendSet node, 64 SendSet node,
142 ParameterElement parameter, 65 ParameterElement parameter,
143 Node rhs, 66 Node rhs,
144 A arg) { 67 A arg) {
145 return bulkHandleError(node, arg); 68 return bulkHandleError(node, arg);
146 } 69 }
147 70
148 @override 71 @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
159 R errorFinalStaticFieldSet( 72 R errorFinalStaticFieldSet(
160 SendSet node, 73 SendSet node,
161 FieldElement field, 74 FieldElement field,
162 Node rhs, 75 Node rhs,
163 A arg) { 76 A arg) {
164 return bulkHandleError(node, arg); 77 return bulkHandleError(node, arg);
165 } 78 }
166 79
167 @override 80 @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
178 R errorFinalSuperFieldSet( 81 R errorFinalSuperFieldSet(
179 SendSet node, 82 SendSet node,
180 FieldElement field, 83 FieldElement field,
181 Node rhs, 84 Node rhs,
182 A arg) { 85 A arg) {
183 return bulkHandleError(node, arg); 86 return bulkHandleError(node, arg);
184 } 87 }
185 88
186 @override 89 @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
197 R errorFinalTopLevelFieldSet( 90 R errorFinalTopLevelFieldSet(
198 SendSet node, 91 SendSet node,
199 FieldElement field, 92 FieldElement field,
200 Node rhs, 93 Node rhs,
201 A arg) { 94 A arg) {
202 return bulkHandleError(node, arg); 95 return bulkHandleError(node, arg);
203 } 96 }
204 97
205 @override 98 @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
234 R errorLocalFunctionSet( 99 R errorLocalFunctionSet(
235 SendSet node, 100 SendSet node,
236 LocalFunctionElement function, 101 LocalFunctionElement function,
237 Node rhs, 102 Node rhs,
238 A arg) { 103 A arg) {
239 return bulkHandleError(node, arg); 104 return bulkHandleError(node, arg);
240 } 105 }
241 106
242 @override 107 @override
243 R errorNonConstantConstructorInvoke( 108 R errorNonConstantConstructorInvoke(
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after
352 R errorTopLevelSetterInvoke( 217 R errorTopLevelSetterInvoke(
353 Send node, 218 Send node,
354 FunctionElement setter, 219 FunctionElement setter,
355 NodeList arguments, 220 NodeList arguments,
356 CallStructure callStructure, 221 CallStructure callStructure,
357 A arg) { 222 A arg) {
358 return bulkHandleError(node, arg); 223 return bulkHandleError(node, arg);
359 } 224 }
360 225
361 @override 226 @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
390 R errorTypeVariableTypeLiteralSet( 227 R errorTypeVariableTypeLiteralSet(
391 SendSet node, 228 SendSet node,
392 TypeVariableElement element, 229 TypeVariableElement element,
393 Node rhs, 230 Node rhs,
394 A arg) { 231 A arg) {
395 return bulkHandleError(node, arg); 232 return bulkHandleError(node, arg);
396 } 233 }
397 234
398 @override 235 @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
427 R errorTypedefTypeLiteralSet( 236 R errorTypedefTypeLiteralSet(
428 SendSet node, 237 SendSet node,
429 ConstantExpression constant, 238 ConstantExpression constant,
430 Node rhs, 239 Node rhs,
431 A arg) { 240 A arg) {
432 return bulkHandleError(node, arg); 241 return bulkHandleError(node, arg);
433 } 242 }
434 243
435 @override 244 @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
464 R errorUnresolvedSet( 245 R errorUnresolvedSet(
465 Send node, 246 Send node,
466 Element element, 247 Element element,
467 Node rhs, 248 Node rhs,
468 A arg) { 249 A arg) {
469 return bulkHandleError(node, arg); 250 return bulkHandleError(node, arg);
470 } 251 }
471 252
472 @override 253 @override
473 R errorUndefinedUnaryExpression( 254 R errorUndefinedUnaryExpression(
(...skipping 152 matching lines...) Expand 10 before | Expand all | Expand 10 after
626 Node index, 407 Node index,
627 IncDecOperator operator, 408 IncDecOperator operator,
628 A arg) { 409 A arg) {
629 return bulkHandlePrefix(node, arg); 410 return bulkHandlePrefix(node, arg);
630 } 411 }
631 412
632 @override 413 @override
633 R visitUnresolvedSuperGetterIndexPrefix( 414 R visitUnresolvedSuperGetterIndexPrefix(
634 Send node, 415 Send node,
635 Element element, 416 Element element,
417 MethodElement setter,
636 Node index, 418 Node index,
637 IncDecOperator operator, 419 IncDecOperator operator,
638 A arg) { 420 A arg) {
639 return bulkHandlePrefix(node, arg); 421 return bulkHandlePrefix(node, arg);
640 } 422 }
641 423
642 @override 424 @override
643 R visitUnresolvedSuperSetterIndexPrefix( 425 R visitUnresolvedSuperSetterIndexPrefix(
644 Send node, 426 Send node,
645 MethodElement getter, 427 MethodElement getter,
646 Element element, 428 Element element,
647 Node index, 429 Node index,
648 IncDecOperator operator, 430 IncDecOperator operator,
649 A arg) { 431 A arg) {
650 return bulkHandlePrefix(node, arg); 432 return bulkHandlePrefix(node, arg);
651 } 433 }
652 434
653 @override 435 @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
654 R visitSuperMethodSetterPrefix( 446 R visitSuperMethodSetterPrefix(
655 Send node, 447 Send node,
656 FunctionElement method, 448 FunctionElement method,
657 FunctionElement setter, 449 FunctionElement setter,
658 IncDecOperator operator, 450 IncDecOperator operator,
659 A arg) { 451 A arg) {
660 return bulkHandlePrefix(node, arg); 452 return bulkHandlePrefix(node, arg);
661 } 453 }
662 454
663 @override 455 @override
(...skipping 27 matching lines...) Expand all
691 483
692 @override 484 @override
693 R visitTopLevelMethodSetterPrefix( 485 R visitTopLevelMethodSetterPrefix(
694 Send node, 486 Send node,
695 FunctionElement method, 487 FunctionElement method,
696 FunctionElement setter, 488 FunctionElement setter,
697 IncDecOperator operator, 489 IncDecOperator operator,
698 A arg) { 490 A arg) {
699 return bulkHandlePrefix(node, arg); 491 return bulkHandlePrefix(node, arg);
700 } 492 }
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 }
701 } 688 }
702 689
703 /// Mixin that implements all `visitXPostfix` methods of [SemanticSendVisitor] 690 /// Mixin that implements all `visitXPostfix` methods of [SemanticSendVisitor]
704 /// by delegating to a bulk handler. 691 /// by delegating to a bulk handler.
705 /// 692 ///
706 /// Use this mixin to provide a trivial implementation for all `visitXPostfix` 693 /// Use this mixin to provide a trivial implementation for all `visitXPostfix`
707 /// methods. 694 /// methods.
708 abstract class PostfixBulkMixin<R, A> 695 abstract class PostfixBulkMixin<R, A>
709 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 696 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
710 697
(...skipping 126 matching lines...) Expand 10 before | Expand all | Expand 10 after
837 Node index, 824 Node index,
838 IncDecOperator operator, 825 IncDecOperator operator,
839 A arg) { 826 A arg) {
840 return bulkHandlePostfix(node, arg); 827 return bulkHandlePostfix(node, arg);
841 } 828 }
842 829
843 @override 830 @override
844 R visitUnresolvedSuperGetterIndexPostfix( 831 R visitUnresolvedSuperGetterIndexPostfix(
845 Send node, 832 Send node,
846 Element element, 833 Element element,
834 MethodElement setter,
847 Node index, 835 Node index,
848 IncDecOperator operator, 836 IncDecOperator operator,
849 A arg) { 837 A arg) {
850 return bulkHandlePostfix(node, arg); 838 return bulkHandlePostfix(node, arg);
851 } 839 }
852 840
853 @override 841 @override
854 R visitUnresolvedSuperSetterIndexPostfix( 842 R visitUnresolvedSuperSetterIndexPostfix(
855 Send node, 843 Send node,
856 MethodElement getter, 844 MethodElement getter,
857 Element element, 845 Element element,
858 Node index, 846 Node index,
859 IncDecOperator operator, 847 IncDecOperator operator,
860 A arg) { 848 A arg) {
861 return bulkHandlePostfix(node, arg); 849 return bulkHandlePostfix(node, arg);
862 } 850 }
863 851
864 @override 852 @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
865 R visitSuperMethodSetterPostfix( 863 R visitSuperMethodSetterPostfix(
866 Send node, 864 Send node,
867 FunctionElement method, 865 FunctionElement method,
868 FunctionElement setter, 866 FunctionElement setter,
869 IncDecOperator operator, 867 IncDecOperator operator,
870 A arg) { 868 A arg) {
871 return bulkHandlePostfix(node, arg); 869 return bulkHandlePostfix(node, arg);
872 } 870 }
873 871
874 @override 872 @override
(...skipping 27 matching lines...) Expand all
902 900
903 @override 901 @override
904 R visitTopLevelMethodSetterPostfix( 902 R visitTopLevelMethodSetterPostfix(
905 Send node, 903 Send node,
906 FunctionElement method, 904 FunctionElement method,
907 FunctionElement setter, 905 FunctionElement setter,
908 IncDecOperator operator, 906 IncDecOperator operator,
909 A arg) { 907 A arg) {
910 return bulkHandlePostfix(node, arg); 908 return bulkHandlePostfix(node, arg);
911 } 909 }
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 }
912 } 1113 }
913 1114
914 /// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor] 1115 /// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor]
915 /// by delegating to a bulk handler. 1116 /// by delegating to a bulk handler.
916 /// 1117 ///
917 /// Use this mixin to provide a trivial implementation for all `xCompound` 1118 /// Use this mixin to provide a trivial implementation for all `xCompound`
918 /// methods. 1119 /// methods.
919 abstract class CompoundBulkMixin<R, A> 1120 abstract class CompoundBulkMixin<R, A>
920 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 1121 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
921 1122
(...skipping 154 matching lines...) Expand 10 before | Expand all | Expand 10 after
1076 @override 1277 @override
1077 R visitTopLevelMethodSetterCompound( 1278 R visitTopLevelMethodSetterCompound(
1078 Send node, 1279 Send node,
1079 FunctionElement method, 1280 FunctionElement method,
1080 FunctionElement setter, 1281 FunctionElement setter,
1081 AssignmentOperator operator, 1282 AssignmentOperator operator,
1082 Node rhs, 1283 Node rhs,
1083 A arg) { 1284 A arg) {
1084 return bulkHandleCompound(node, arg); 1285 return bulkHandleCompound(node, arg);
1085 } 1286 }
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 }
1086 } 1512 }
1087 1513
1088 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by 1514 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by
1089 /// delegating to a bulk handler. 1515 /// delegating to a bulk handler.
1090 /// 1516 ///
1091 /// Use this mixin to provide a trivial implementation for all `visitXInvoke` 1517 /// Use this mixin to provide a trivial implementation for all `visitXInvoke`
1092 /// methods. 1518 /// methods.
1093 abstract class InvokeBulkMixin<R, A> 1519 abstract class InvokeBulkMixin<R, A>
1094 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 1520 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
1095 1521
(...skipping 593 matching lines...) Expand 10 before | Expand all | Expand 10 after
1689 AssignmentOperator operator, 2115 AssignmentOperator operator,
1690 Node rhs, 2116 Node rhs,
1691 A arg) { 2117 A arg) {
1692 return bulkHandleIndexSet(node, arg); 2118 return bulkHandleIndexSet(node, arg);
1693 } 2119 }
1694 2120
1695 @override 2121 @override
1696 R visitUnresolvedSuperGetterCompoundIndexSet( 2122 R visitUnresolvedSuperGetterCompoundIndexSet(
1697 SendSet node, 2123 SendSet node,
1698 Element element, 2124 Element element,
2125 MethodElement setter,
1699 Node index, 2126 Node index,
1700 AssignmentOperator operator, 2127 AssignmentOperator operator,
1701 Node rhs, 2128 Node rhs,
1702 A arg) { 2129 A arg) {
1703 return bulkHandleIndexSet(node, arg); 2130 return bulkHandleIndexSet(node, arg);
1704 } 2131 }
1705 2132
1706 @override 2133 @override
1707 R visitUnresolvedSuperSetterCompoundIndexSet( 2134 R visitUnresolvedSuperSetterCompoundIndexSet(
1708 SendSet node, 2135 SendSet node,
1709 MethodElement getter, 2136 MethodElement getter,
1710 Element element, 2137 Element element,
1711 Node index, 2138 Node index,
1712 AssignmentOperator operator, 2139 AssignmentOperator operator,
1713 Node rhs, 2140 Node rhs,
1714 A arg) { 2141 A arg) {
1715 return bulkHandleIndexSet(node, arg); 2142 return bulkHandleIndexSet(node, arg);
1716 } 2143 }
1717 2144
1718 @override 2145 @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
1719 R visitSuperIndexSet( 2157 R visitSuperIndexSet(
1720 SendSet node, 2158 SendSet node,
1721 FunctionElement function, 2159 FunctionElement function,
1722 Node index, 2160 Node index,
1723 Node rhs, 2161 Node rhs,
1724 A arg) { 2162 A arg) {
1725 return bulkHandleIndexSet(node, arg); 2163 return bulkHandleIndexSet(node, arg);
1726 } 2164 }
1727 2165
1728 @override 2166 @override
(...skipping 625 matching lines...) Expand 10 before | Expand all | Expand 10 after
2354 } 2792 }
2355 2793
2356 @override 2794 @override
2357 R visitConstConstructorInvoke( 2795 R visitConstConstructorInvoke(
2358 NewExpression node, 2796 NewExpression node,
2359 ConstructedConstantExpression constant, 2797 ConstructedConstantExpression constant,
2360 A arg) { 2798 A arg) {
2361 return bulkHandleNew(node, arg); 2799 return bulkHandleNew(node, arg);
2362 } 2800 }
2363 2801
2802 @override
2364 R visitGenerativeConstructorInvoke( 2803 R visitGenerativeConstructorInvoke(
2365 NewExpression node, 2804 NewExpression node,
2366 ConstructorElement constructor, 2805 ConstructorElement constructor,
2367 InterfaceType type, 2806 InterfaceType type,
2368 NodeList arguments, 2807 NodeList arguments,
2369 CallStructure callStructure, 2808 CallStructure callStructure,
2370 A arg) { 2809 A arg) {
2371 return bulkHandleNew(node, arg); 2810 return bulkHandleNew(node, arg);
2372 } 2811 }
2373 2812
2813 @override
2374 R visitRedirectingGenerativeConstructorInvoke( 2814 R visitRedirectingGenerativeConstructorInvoke(
2375 NewExpression node, 2815 NewExpression node,
2376 ConstructorElement constructor, 2816 ConstructorElement constructor,
2377 InterfaceType type, 2817 InterfaceType type,
2378 NodeList arguments, 2818 NodeList arguments,
2379 CallStructure callStructure, 2819 CallStructure callStructure,
2380 A arg) { 2820 A arg) {
2381 return bulkHandleNew(node, arg); 2821 return bulkHandleNew(node, arg);
2382 } 2822 }
2383 2823
2824 @override
2384 R visitFactoryConstructorInvoke( 2825 R visitFactoryConstructorInvoke(
2385 NewExpression node, 2826 NewExpression node,
2386 ConstructorElement constructor, 2827 ConstructorElement constructor,
2387 InterfaceType type, 2828 InterfaceType type,
2388 NodeList arguments, 2829 NodeList arguments,
2389 CallStructure callStructure, 2830 CallStructure callStructure,
2390 A arg) { 2831 A arg) {
2391 return bulkHandleNew(node, arg); 2832 return bulkHandleNew(node, arg);
2392 } 2833 }
2393 2834
2835 @override
2394 R visitRedirectingFactoryConstructorInvoke( 2836 R visitRedirectingFactoryConstructorInvoke(
2395 NewExpression node, 2837 NewExpression node,
2396 ConstructorElement constructor, 2838 ConstructorElement constructor,
2397 InterfaceType type, 2839 InterfaceType type,
2398 ConstructorElement effectiveTarget, 2840 ConstructorElement effectiveTarget,
2399 InterfaceType effectiveTargetType, 2841 InterfaceType effectiveTargetType,
2400 NodeList arguments, 2842 NodeList arguments,
2401 CallStructure callStructure, 2843 CallStructure callStructure,
2402 A arg) { 2844 A arg) {
2403 return bulkHandleNew(node, arg); 2845 return bulkHandleNew(node, arg);
(...skipping 558 matching lines...) Expand 10 before | Expand all | Expand 10 after
2962 return null; 3404 return null;
2963 } 3405 }
2964 3406
2965 @override 3407 @override
2966 R errorDynamicTypeLiteralSet( 3408 R errorDynamicTypeLiteralSet(
2967 SendSet node, 3409 SendSet node,
2968 ConstantExpression constant, 3410 ConstantExpression constant,
2969 Node rhs, 3411 Node rhs,
2970 A arg) { 3412 A arg) {
2971 apply(rhs, arg); 3413 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);
3657 return null;
3658 }
3659
3660 @override
3661 R visitLogicalAnd(
3662 Send node,
3663 Node left,
3664 Node right,
3665 A arg) {
3666 apply(left, arg);
3667 apply(right, arg);
3668 return null;
3669 }
3670
3671 @override
3672 R visitLogicalOr(
3673 Send node,
3674 Node left,
3675 Node right,
3676 A arg) {
3677 apply(left, arg);
3678 apply(right, arg);
3679 return null;
3680 }
3681
3682 @override
3683 R visitNot(
3684 Send node,
3685 Node expression,
3686 A arg) {
3687 apply(expression, arg);
3688 return null;
3689 }
3690
3691 @override
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(
3704 Send node,
3705 ParameterElement parameter,
3706 AssignmentOperator operator,
3707 Node rhs,
3708 A arg) {
3709 apply(rhs, arg);
3710 return null; 3414 return null;
3711 } 3415 }
3712 3416
3713 @override 3417 @override
3714 R visitParameterGet( 3418 R visitFinalLocalVariableCompound(
3715 Send node, 3419 Send node,
3716 ParameterElement parameter, 3420 LocalVariableElement variable,
3421 AssignmentOperator operator,
3422 Node rhs,
3717 A arg) { 3423 A arg) {
3424 apply(rhs, arg);
3718 return null; 3425 return null;
3719 } 3426 }
3720 3427
3721 @override 3428 @override
3722 R visitParameterInvoke( 3429 R errorFinalLocalVariableSet(
3723 Send node, 3430 SendSet node,
3724 ParameterElement parameter, 3431 LocalVariableElement variable,
3725 NodeList arguments, 3432 Node rhs,
3726 CallStructure callStructure,
3727 A arg) { 3433 A arg) {
3728 apply(arguments, arg); 3434 apply(rhs, arg);
3729 return null; 3435 return null;
3730 } 3436 }
3731 3437
3732 @override 3438 @override
3733 R visitParameterPostfix( 3439 R visitFinalParameterCompound(
3734 Send node, 3440 Send node,
3735 ParameterElement parameter, 3441 ParameterElement parameter,
3736 IncDecOperator operator, 3442 AssignmentOperator operator,
3443 Node rhs,
3737 A arg) { 3444 A arg) {
3445 apply(rhs, arg);
3738 return null; 3446 return null;
3739 } 3447 }
3740 3448
3741 @override 3449 @override
3742 R visitParameterPrefix( 3450 R errorFinalParameterSet(
3743 Send node,
3744 ParameterElement parameter,
3745 IncDecOperator operator,
3746 A arg) {
3747 return null;
3748 }
3749
3750 @override
3751 R visitParameterSet(
3752 SendSet node, 3451 SendSet node,
3753 ParameterElement parameter, 3452 ParameterElement parameter,
3754 Node rhs, 3453 Node rhs,
3755 A arg) { 3454 A arg) {
3756 apply(rhs, arg); 3455 apply(rhs, arg);
3757 return null; 3456 return null;
3758 } 3457 }
3759 3458
3760 @override 3459 @override
3761 R visitStaticFieldCompound( 3460 R visitFinalStaticFieldCompound(
3762 Send node, 3461 Send node,
3763 FieldElement field, 3462 FieldElement field,
3764 AssignmentOperator operator, 3463 AssignmentOperator operator,
3765 Node rhs, 3464 Node rhs,
3766 A arg) { 3465 A arg) {
3767 apply(rhs, arg); 3466 apply(rhs, arg);
3768 return null; 3467 return null;
3769 } 3468 }
3770 3469
3771 @override 3470 @override
3772 R visitStaticFieldGet( 3471 R errorFinalStaticFieldSet(
3773 Send node, 3472 SendSet node,
3774 FieldElement field, 3473 FieldElement field,
3474 Node rhs,
3775 A arg) { 3475 A arg) {
3476 apply(rhs, arg);
3776 return null; 3477 return null;
3777 } 3478 }
3778 3479
3779 @override 3480 @override
3780 R visitStaticFieldInvoke( 3481 R errorFinalSuperFieldSet(
3781 Send node, 3482 SendSet node,
3782 FieldElement field, 3483 FieldElement field,
3783 NodeList arguments, 3484 Node rhs,
3784 CallStructure callStructure,
3785 A arg) { 3485 A arg) {
3786 apply(arguments, arg); 3486 apply(rhs, arg);
3787 return null; 3487 return null;
3788 } 3488 }
3789 3489
3790 @override 3490 @override
3791 R visitStaticFieldPostfix( 3491 R visitFinalTopLevelFieldCompound(
3792 Send node, 3492 Send node,
3793 FieldElement field, 3493 FieldElement field,
3794 IncDecOperator operator, 3494 AssignmentOperator operator,
3495 Node rhs,
3795 A arg) { 3496 A arg) {
3497 apply(rhs, arg);
3796 return null; 3498 return null;
3797 } 3499 }
3798 3500
3799 @override 3501 @override
3800 R visitStaticFieldPrefix( 3502 R errorFinalTopLevelFieldSet(
3801 Send node,
3802 FieldElement field,
3803 IncDecOperator operator,
3804 A arg) {
3805 return null;
3806 }
3807
3808 @override
3809 R visitStaticFieldSet(
3810 SendSet node, 3503 SendSet node,
3811 FieldElement field, 3504 FieldElement field,
3812 Node rhs, 3505 Node rhs,
3813 A arg) { 3506 A arg) {
3814 apply(rhs, arg); 3507 apply(rhs, arg);
3815 return null; 3508 return null;
3816 } 3509 }
3817 3510
3818 @override 3511 @override
3819 R visitStaticFunctionGet( 3512 R visitLocalFunctionCompound(
3820 Send node, 3513 Send node,
3821 MethodElement function, 3514 LocalFunctionElement function,
3515 AssignmentOperator operator,
3516 Node rhs,
3517 A arg) {
3518 apply(rhs, arg);
3519 return null;
3520 }
3521
3522 @override
3523 R visitLocalFunctionPostfix(
3524 Send node,
3525 LocalFunctionElement function,
3526 IncDecOperator operator,
3822 A arg) { 3527 A arg) {
3823 return null; 3528 return null;
3824 } 3529 }
3825 3530
3826 @override 3531 @override
3827 R visitStaticFunctionInvoke( 3532 R visitLocalFunctionPrefix(
3828 Send node, 3533 Send node,
3829 MethodElement function, 3534 LocalFunctionElement function,
3830 NodeList arguments, 3535 IncDecOperator operator,
3831 CallStructure callStructure,
3832 A arg) {
3833 apply(arguments, arg);
3834 return null;
3835 }
3836
3837 @override
3838 R visitStaticFunctionIncompatibleInvoke(
3839 Send node,
3840 MethodElement function,
3841 NodeList arguments,
3842 CallStructure callStructure,
3843 A arg) {
3844 apply(arguments, arg);
3845 return null;
3846 }
3847
3848 @override
3849 R visitStaticGetterGet(
3850 Send node,
3851 FunctionElement getter,
3852 A arg) { 3536 A arg) {
3853 return null; 3537 return null;
3854 } 3538 }
3855 3539
3856 @override 3540 @override
3857 R visitStaticGetterInvoke( 3541 R errorLocalFunctionSet(
3858 Send node, 3542 SendSet node,
3859 FunctionElement getter, 3543 LocalFunctionElement function,
3860 NodeList arguments, 3544 Node rhs,
3861 CallStructure callStructure,
3862 A arg) { 3545 A arg) {
3863 apply(arguments, arg); 3546 apply(rhs, arg);
3864 return null; 3547 return null;
3865 } 3548 }
3866 3549
3867 @override 3550 @override
3868 R visitStaticGetterSetterCompound( 3551 R errorStaticFunctionSet(
3869 Send node, 3552 Send node,
3870 FunctionElement getter, 3553 MethodElement function,
3871 FunctionElement setter,
3872 AssignmentOperator operator,
3873 Node rhs, 3554 Node rhs,
3874 A arg) { 3555 A arg) {
3875 apply(rhs, 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);
3876 return null; 3567 return null;
3877 } 3568 }
3878 3569
3879 @override 3570 @override
3880 R visitStaticGetterSetterPostfix( 3571 R errorStaticSetterGet(
3881 Send node, 3572 Send node,
3882 FunctionElement getter,
3883 FunctionElement setter, 3573 FunctionElement setter,
3884 IncDecOperator operator,
3885 A arg) { 3574 A arg) {
3886 return null; 3575 return null;
3887 } 3576 }
3888 3577
3889 @override 3578 @override
3890 R visitStaticGetterSetterPrefix( 3579 R errorStaticSetterInvoke(
3891 Send node, 3580 Send node,
3892 FunctionElement getter,
3893 FunctionElement setter, 3581 FunctionElement setter,
3894 IncDecOperator operator, 3582 NodeList arguments,
3583 CallStructure callStructure,
3895 A arg) { 3584 A arg) {
3585 apply(arguments, arg);
3896 return null; 3586 return null;
3897 } 3587 }
3898 3588
3899 @override 3589 @override
3900 R visitStaticMethodSetterCompound( 3590 R errorSuperGetterSet(
3901 Send node, 3591 SendSet node,
3902 FunctionElement method, 3592 FunctionElement getter,
3903 FunctionElement setter,
3904 AssignmentOperator operator,
3905 Node rhs, 3593 Node rhs,
3906 A arg) { 3594 A arg) {
3907 apply(rhs, arg); 3595 apply(rhs, arg);
3908 return null; 3596 return null;
3909 } 3597 }
3910 3598
3911 @override 3599 @override
3912 R visitStaticMethodSetterPostfix( 3600 R errorSuperMethodSet(
3913 Send node, 3601 Send node,
3914 FunctionElement getter, 3602 MethodElement method,
3915 FunctionElement setter,
3916 IncDecOperator operator,
3917 A arg) {
3918 return null;
3919 }
3920
3921 @override
3922 R visitStaticMethodSetterPrefix(
3923 Send node,
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, 3603 Node rhs,
3936 A arg) { 3604 A arg) {
3937 apply(rhs, arg); 3605 apply(rhs, arg);
3938 return null; 3606 return null;
3939 } 3607 }
3940 3608
3941 @override 3609 @override
3942 R visitSuperBinary( 3610 R errorSuperSetterGet(
3943 Send node, 3611 Send node,
3944 FunctionElement function, 3612 FunctionElement setter,
3945 BinaryOperator operator,
3946 Node argument,
3947 A arg) { 3613 A arg) {
3948 apply(argument, arg);
3949 return null; 3614 return null;
3950 } 3615 }
3951 3616
3952 @override 3617 @override
3953 R visitSuperCompoundIndexSet( 3618 R errorSuperSetterInvoke(
3954 SendSet node, 3619 Send node,
3955 FunctionElement getter,
3956 FunctionElement setter, 3620 FunctionElement setter,
3957 Node index, 3621 NodeList arguments,
3958 AssignmentOperator operator, 3622 CallStructure callStructure,
3623 A arg) {
3624 apply(arguments, arg);
3625 return null;
3626 }
3627
3628 @override
3629 R errorTopLevelFunctionSet(
3630 Send node,
3631 MethodElement function,
3959 Node rhs, 3632 Node rhs,
3960 A arg) { 3633 A arg) {
3961 apply(rhs, arg); 3634 apply(rhs, arg);
3635 return null;
3636 }
3637
3638 @override
3639 R errorTopLevelGetterSet(
3640 SendSet node,
3641 FunctionElement getter,
3642 Node rhs,
3643 A arg) {
3644 apply(rhs, arg);
3962 return null; 3645 return null;
3963 } 3646 }
3964 3647
3965 @override 3648 @override
3966 R visitSuperEquals( 3649 R errorTopLevelSetterGet(
3967 Send node, 3650 Send node,
3968 FunctionElement function, 3651 FunctionElement setter,
3969 Node argument,
3970 A arg) { 3652 A arg) {
3971 apply(argument, arg);
3972 return null; 3653 return null;
3973 } 3654 }
3974 3655
3975 @override 3656 @override
3976 R visitSuperFieldCompound( 3657 R errorTopLevelSetterInvoke(
3977 Send node, 3658 Send node,
3978 FieldElement field, 3659 FunctionElement setter,
3979 AssignmentOperator operator, 3660 NodeList arguments,
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,
3980 Node rhs, 3671 Node rhs,
3981 A arg) { 3672 A arg) {
3982 apply(rhs, arg); 3673 apply(rhs, arg);
3983 return null; 3674 return null;
3984 } 3675 }
3985 3676
3986 @override 3677 @override
3987 R visitSuperFieldFieldPostfix( 3678 R errorTypedefTypeLiteralSet(
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,
4018 NodeList arguments,
4019 CallStructure callStructure,
4020 A arg) {
4021 apply(arguments, arg);
4022 return null;
4023 }
4024
4025 @override
4026 R visitSuperFieldPostfix(
4027 Send node,
4028 FieldElement field,
4029 IncDecOperator operator,
4030 A arg) {
4031 return null;
4032 }
4033
4034 @override
4035 R visitSuperFieldPrefix(
4036 Send node,
4037 FieldElement field,
4038 IncDecOperator operator,
4039 A arg) {
4040 return null;
4041 }
4042
4043 @override
4044 R visitSuperFieldSet(
4045 SendSet node, 3679 SendSet node,
4046 FieldElement field, 3680 ConstantExpression constant,
4047 Node rhs, 3681 Node rhs,
4048 A arg) { 3682 A arg) {
4049 apply(rhs, arg); 3683 apply(rhs, arg);
4050 return null; 3684 return null;
4051 } 3685 }
4052 3686
4053 @override 3687 @override
4054 R visitSuperFieldSetterCompound( 3688 R visitUnresolvedSuperIndex(
4055 Send node, 3689 Send node,
4056 FieldElement field, 3690 Element function,
4057 FunctionElement setter, 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) {
3702 return null;
3703 }
3704
3705 @override
3706 R visitUnresolvedSuperInvoke(
3707 Send node,
3708 Element function,
3709 NodeList arguments,
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,
4058 AssignmentOperator operator, 3751 AssignmentOperator operator,
4059 Node rhs, 3752 Node rhs,
4060 A arg) { 3753 A arg) {
4061 apply(rhs, arg); 3754 apply(rhs, arg);
4062 return null; 3755 return null;
4063 } 3756 }
4064 3757
4065 @override 3758 @override
4066 R visitSuperFieldSetterPostfix( 3759 R visitClassTypeLiteralGet(
4067 Send node, 3760 Send node,
4068 FieldElement field, 3761 ConstantExpression constant,
4069 FunctionElement setter, 3762 A arg) {
3763 return null;
3764 }
3765
3766 @override
3767 R visitClassTypeLiteralInvoke(
3768 Send node,
3769 ConstantExpression constant,
3770 NodeList arguments,
3771 CallStructure callStructure,
3772 A arg) {
3773 apply(arguments, arg);
3774 return null;
3775 }
3776
3777 @override
3778 R visitClassTypeLiteralPostfix(
3779 Send node,
3780 ConstantExpression constant,
4070 IncDecOperator operator, 3781 IncDecOperator operator,
4071 A arg) { 3782 A arg) {
4072 return null; 3783 return null;
4073 } 3784 }
4074 3785
4075 @override 3786 @override
4076 R visitSuperFieldSetterPrefix( 3787 R visitClassTypeLiteralPrefix(
4077 Send node, 3788 Send node,
4078 FieldElement field, 3789 ConstantExpression constant,
4079 FunctionElement setter,
4080 IncDecOperator operator, 3790 IncDecOperator operator,
4081 A arg) { 3791 A arg) {
4082 return null; 3792 return null;
4083 } 3793 }
4084 3794
4085 @override 3795 @override
4086 R visitSuperGetterFieldCompound( 3796 R visitCompoundIndexSet(
4087 Send node, 3797 SendSet node,
4088 FunctionElement getter, 3798 Node receiver,
4089 FieldElement field, 3799 Node index,
4090 AssignmentOperator operator, 3800 AssignmentOperator operator,
4091 Node rhs, 3801 Node rhs,
4092 A arg) { 3802 A arg) {
3803 apply(receiver, arg);
3804 apply(index, arg);
4093 apply(rhs, arg); 3805 apply(rhs, arg);
4094 return null; 3806 return null;
4095 } 3807 }
4096 3808
4097 @override 3809 @override
4098 R visitSuperGetterFieldPostfix( 3810 R visitConstantGet(
4099 Send node, 3811 Send node,
4100 FunctionElement getter, 3812 ConstantExpression constant,
4101 FieldElement field,
4102 IncDecOperator operator,
4103 A arg) { 3813 A arg) {
4104 return null; 3814 return null;
4105 } 3815 }
4106 3816
4107 @override 3817 @override
4108 R visitSuperGetterFieldPrefix( 3818 R visitConstantInvoke(
4109 Send node, 3819 Send node,
4110 FunctionElement getter, 3820 ConstantExpression constant,
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,
4129 NodeList arguments, 3821 NodeList arguments,
4130 CallStructure callStructure, 3822 CallStructure callStructure,
4131 A arg) { 3823 A arg) {
4132 apply(arguments, arg); 3824 apply(arguments, arg);
4133 return null; 3825 return null;
4134 } 3826 }
4135 3827
4136 @override 3828 @override
4137 R visitSuperGetterSetterCompound( 3829 R visitDynamicPropertyCompound(
4138 Send node, 3830 Send node,
4139 FunctionElement getter, 3831 Node receiver,
4140 FunctionElement setter, 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,
3894 A arg) {
3895 apply(rhs, arg);
3896 return null;
3897 }
3898
3899 @override
3900 R visitDynamicTypeLiteralCompound(
3901 Send node,
3902 ConstantExpression constant,
4141 AssignmentOperator operator, 3903 AssignmentOperator operator,
4142 Node rhs, 3904 Node rhs,
4143 A arg) { 3905 A arg) {
4144 apply(rhs, arg); 3906 apply(rhs, arg);
4145 return null; 3907 return null;
4146 } 3908 }
4147 3909
4148 @override 3910 @override
4149 R visitSuperGetterSetterPostfix( 3911 R visitDynamicTypeLiteralGet(
4150 Send node, 3912 Send node,
4151 FunctionElement getter, 3913 ConstantExpression constant,
4152 FunctionElement setter,
4153 IncDecOperator operator,
4154 A arg) { 3914 A arg) {
4155 return null; 3915 return null;
4156 } 3916 }
4157 3917
4158 @override 3918 @override
4159 R visitSuperGetterSetterPrefix( 3919 R visitDynamicTypeLiteralInvoke(
4160 Send node, 3920 Send node,
4161 FunctionElement getter, 3921 ConstantExpression constant,
4162 FunctionElement setter,
4163 IncDecOperator operator,
4164 A arg) {
4165 return null;
4166 }
4167
4168 @override
4169 R visitSuperIndex(
4170 Send node,
4171 FunctionElement function,
4172 Node index,
4173 A arg) {
4174 apply(index, arg);
4175 return null;
4176 }
4177
4178 @override
4179 R visitSuperIndexSet(
4180 SendSet node,
4181 FunctionElement function,
4182 Node index,
4183 Node rhs,
4184 A arg) {
4185 apply(index, arg);
4186 apply(rhs, arg);
4187 return null;
4188 }
4189
4190 @override
4191 R visitSuperMethodGet(
4192 Send node,
4193 MethodElement method,
4194 A arg) {
4195 return null;
4196 }
4197
4198 @override
4199 R visitSuperMethodInvoke(
4200 Send node,
4201 MethodElement method,
4202 NodeList arguments, 3922 NodeList arguments,
4203 CallStructure callStructure, 3923 CallStructure callStructure,
4204 A arg) { 3924 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) {
4216 apply(arguments, arg); 3925 apply(arguments, arg);
4217 return null; 3926 return null;
4218 } 3927 }
4219 3928
4220 @override 3929 @override
4221 R visitSuperMethodSetterCompound( 3930 R visitDynamicTypeLiteralPostfix(
4222 Send node, 3931 Send node,
4223 FunctionElement method, 3932 ConstantExpression constant,
4224 FunctionElement setter,
4225 AssignmentOperator operator,
4226 Node rhs,
4227 A arg) {
4228 apply(rhs, arg);
4229 return null;
4230 }
4231
4232 @override
4233 R visitSuperMethodSetterPostfix(
4234 Send node,
4235 FunctionElement method,
4236 FunctionElement setter,
4237 IncDecOperator operator, 3933 IncDecOperator operator,
4238 A arg) { 3934 A arg) {
4239 return null; 3935 return null;
4240 } 3936 }
4241 3937
4242 @override 3938 @override
4243 R visitSuperMethodSetterPrefix( 3939 R visitDynamicTypeLiteralPrefix(
4244 Send node, 3940 Send node,
4245 FunctionElement method, 3941 ConstantExpression constant,
4246 FunctionElement setter,
4247 IncDecOperator operator, 3942 IncDecOperator operator,
4248 A arg) { 3943 A arg) {
4249 return null; 3944 return null;
4250 } 3945 }
4251 3946
4252 @override 3947 @override
4253 R visitSuperNotEquals( 3948 R visitEquals(
4254 Send node, 3949 Send node,
4255 FunctionElement function, 3950 Node left,
4256 Node argument, 3951 Node right,
4257 A arg) { 3952 A arg) {
4258 apply(argument, arg); 3953 apply(left, arg);
3954 apply(right, arg);
4259 return null; 3955 return null;
4260 } 3956 }
4261 3957
4262 @override 3958 @override
4263 R visitSuperSetterSet( 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,
3975 A arg) {
3976 apply(receiver, arg);
3977 apply(index, arg);
3978 return null;
3979 }
3980
3981 @override
3982 R visitIndexSet(
4264 SendSet node, 3983 SendSet node,
4265 FunctionElement setter, 3984 Node receiver,
3985 Node index,
4266 Node rhs, 3986 Node rhs,
4267 A arg) { 3987 A arg) {
3988 apply(receiver, arg);
3989 apply(index, arg);
4268 apply(rhs, arg); 3990 apply(rhs, arg);
4269 return null; 3991 return null;
4270 } 3992 }
4271 3993
4272 @override 3994 @override
4273 R visitSuperUnary( 3995 R visitIs(
4274 Send node, 3996 Send node,
4275 UnaryOperator operator, 3997 Node expression,
4276 FunctionElement function, 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,
4277 A arg) { 4018 A arg) {
4278 return null; 4019 return null;
4279 } 4020 }
4280 4021
4281 @override 4022 @override
4282 R visitThisGet(Identifier node, A arg) { 4023 R visitLocalFunctionInvoke(
4283 return null;
4284 }
4285
4286 @override
4287 R visitThisInvoke(
4288 Send node, 4024 Send node,
4025 LocalFunctionElement function,
4289 NodeList arguments, 4026 NodeList arguments,
4290 CallStructure callStructure, 4027 CallStructure callStructure,
4291 A arg) { 4028 A arg) {
4292 apply(arguments, arg); 4029 apply(arguments, arg);
4293 return null; 4030 return null;
4294 } 4031 }
4295 4032
4296 @override 4033 @override
4297 R visitThisPropertyCompound( 4034 R visitLocalVariableCompound(
4298 Send node, 4035 Send node,
4036 LocalVariableElement variable,
4299 AssignmentOperator operator, 4037 AssignmentOperator operator,
4300 Node rhs, 4038 Node rhs,
4301 Selector getterSelector,
4302 Selector setterSelector,
4303 A arg) { 4039 A arg) {
4304 apply(rhs, arg); 4040 apply(rhs, arg);
4305 return null; 4041 return null;
4306 } 4042 }
4307 4043
4308 @override 4044 @override
4309 R visitThisPropertyGet( 4045 R visitLocalVariableGet(
4310 Send node, 4046 Send node,
4311 Selector selector, 4047 LocalVariableElement variable,
4312 A arg) { 4048 A arg) {
4313 return null; 4049 return null;
4314 } 4050 }
4315 4051
4316 @override 4052 @override
4317 R visitThisPropertyInvoke( 4053 R visitLocalVariableInvoke(
4318 Send node, 4054 Send node,
4055 LocalVariableElement variable,
4319 NodeList arguments, 4056 NodeList arguments,
4320 Selector selector, 4057 CallStructure callStructure,
4321 A arg) { 4058 A arg) {
4322 apply(arguments, arg); 4059 apply(arguments, arg);
4323 return null; 4060 return null;
4324 } 4061 }
4325 4062
4326 @override 4063 @override
4327 R visitThisPropertyPostfix( 4064 R visitLocalVariablePostfix(
4328 Send node, 4065 Send node,
4066 LocalVariableElement variable,
4329 IncDecOperator operator, 4067 IncDecOperator operator,
4330 Selector getterSelector,
4331 Selector setterSelector,
4332 A arg) { 4068 A arg) {
4333 return null; 4069 return null;
4334 } 4070 }
4335 4071
4336 @override 4072 @override
4337 R visitThisPropertyPrefix( 4073 R visitLocalVariablePrefix(
4338 Send node, 4074 Send node,
4075 LocalVariableElement variable,
4339 IncDecOperator operator, 4076 IncDecOperator operator,
4340 Selector getterSelector,
4341 Selector setterSelector,
4342 A arg) { 4077 A arg) {
4343 return null; 4078 return null;
4344 } 4079 }
4345 4080
4346 @override 4081 @override
4347 R visitThisPropertySet( 4082 R visitLocalVariableSet(
4348 SendSet node, 4083 SendSet node,
4349 Selector selector, 4084 LocalVariableElement variable,
4350 Node rhs, 4085 Node rhs,
4351 A arg) { 4086 A arg) {
4352 apply(rhs, arg); 4087 apply(rhs, arg);
4353 return null; 4088 return null;
4354 } 4089 }
4355 4090
4356 @override 4091 @override
4357 R visitTopLevelFieldCompound( 4092 R visitLogicalAnd(
4358 Send node, 4093 Send node,
4359 FieldElement field, 4094 Node left,
4095 Node right,
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,
4360 AssignmentOperator operator, 4137 AssignmentOperator operator,
4361 Node rhs, 4138 Node rhs,
4362 A arg) { 4139 A arg) {
4363 apply(rhs, arg); 4140 apply(rhs, arg);
4364 return null;
4365 }
4366
4367 @override
4368 R visitTopLevelFieldGet(
4369 Send node,
4370 FieldElement field,
4371 A arg) {
4372 return null;
4373 }
4374
4375 @override
4376 R visitTopLevelFieldInvoke(
4377 Send node,
4378 FieldElement field,
4379 NodeList arguments,
4380 CallStructure callStructure,
4381 A arg) {
4382 apply(arguments, arg);
4383 return null;
4384 }
4385
4386 @override
4387 R visitTopLevelFieldPostfix(
4388 Send node,
4389 FieldElement field,
4390 IncDecOperator operator,
4391 A arg) {
4392 return null;
4393 }
4394
4395 @override
4396 R visitTopLevelFieldPrefix(
4397 Send node,
4398 FieldElement field,
4399 IncDecOperator operator,
4400 A arg) {
4401 return null;
4402 }
4403
4404 @override
4405 R visitTopLevelFieldSet(
4406 SendSet node,
4407 FieldElement field,
4408 Node rhs,
4409 A arg) {
4410 apply(rhs, arg);
4411 return null; 4141 return null;
4412 } 4142 }
4413 4143
4414 @override 4144 @override
4415 R visitTopLevelFunctionGet( 4145 R visitParameterGet(
4416 Send node, 4146 Send node,
4417 MethodElement function, 4147 ParameterElement parameter,
4418 A arg) { 4148 A arg) {
4419 return null; 4149 return null;
4420 } 4150 }
4421 4151
4422 @override 4152 @override
4423 R visitTopLevelFunctionInvoke( 4153 R visitParameterInvoke(
4424 Send node, 4154 Send node,
4425 MethodElement function, 4155 ParameterElement parameter,
4426 NodeList arguments, 4156 NodeList arguments,
4427 CallStructure callStructure, 4157 CallStructure callStructure,
4428 A arg) { 4158 A arg) {
4429 apply(arguments, arg); 4159 apply(arguments, arg);
4430 return null; 4160 return null;
4431 } 4161 }
4432 4162
4433 @override 4163 @override
4434 R visitTopLevelFunctionIncompatibleInvoke( 4164 R visitParameterPostfix(
4435 Send node, 4165 Send node,
4436 MethodElement function, 4166 ParameterElement parameter,
4437 NodeList arguments, 4167 IncDecOperator operator,
4438 CallStructure callStructure,
4439 A arg) {
4440 apply(arguments, arg);
4441 return null;
4442 }
4443
4444 @override
4445 R visitTopLevelGetterGet(
4446 Send node,
4447 FunctionElement getter,
4448 A arg) { 4168 A arg) {
4449 return null; 4169 return null;
4450 } 4170 }
4451 4171
4452 @override 4172 @override
4453 R visitTopLevelGetterInvoke( 4173 R visitParameterPrefix(
4454 Send node, 4174 Send node,
4455 FunctionElement getter, 4175 ParameterElement parameter,
4456 NodeList arguments, 4176 IncDecOperator operator,
4457 CallStructure callStructure,
4458 A arg) { 4177 A arg) {
4459 apply(arguments, arg);
4460 return null; 4178 return null;
4461 } 4179 }
4462 4180
4463 @override 4181 @override
4464 R visitTopLevelGetterSetterCompound( 4182 R visitParameterSet(
4183 SendSet node,
4184 ParameterElement parameter,
4185 Node rhs,
4186 A arg) {
4187 apply(rhs, arg);
4188 return null;
4189 }
4190
4191 @override
4192 R visitStaticFieldCompound(
4465 Send node, 4193 Send node,
4466 FunctionElement getter, 4194 FieldElement field,
4467 FunctionElement setter,
4468 AssignmentOperator operator, 4195 AssignmentOperator operator,
4469 Node rhs, 4196 Node rhs,
4470 A arg) { 4197 A arg) {
4471 apply(rhs, arg); 4198 apply(rhs, arg);
4472 return null; 4199 return null;
4473 } 4200 }
4474 4201
4475 @override 4202 @override
4476 R visitTopLevelGetterSetterPostfix( 4203 R visitStaticFieldGet(
4477 Send node, 4204 Send node,
4478 FunctionElement getter, 4205 FieldElement field,
4479 FunctionElement setter, 4206 A arg) {
4207 return null;
4208 }
4209
4210 @override
4211 R visitStaticFieldInvoke(
4212 Send node,
4213 FieldElement field,
4214 NodeList arguments,
4215 CallStructure callStructure,
4216 A arg) {
4217 apply(arguments, arg);
4218 return null;
4219 }
4220
4221 @override
4222 R visitStaticFieldPostfix(
4223 Send node,
4224 FieldElement field,
4480 IncDecOperator operator, 4225 IncDecOperator operator,
4481 A arg) { 4226 A arg) {
4482 return null; 4227 return null;
4483 } 4228 }
4484 4229
4485 @override 4230 @override
4486 R visitTopLevelGetterSetterPrefix( 4231 R visitStaticFieldPrefix(
4487 Send node, 4232 Send node,
4488 FunctionElement getter, 4233 FieldElement field,
4489 FunctionElement setter,
4490 IncDecOperator operator, 4234 IncDecOperator operator,
4491 A arg) { 4235 A arg) {
4492 return null; 4236 return null;
4493 } 4237 }
4494 4238
4495 @override 4239 @override
4496 R visitTopLevelMethodSetterCompound( 4240 R visitStaticFieldSet(
4497 Send node, 4241 SendSet node,
4498 FunctionElement method, 4242 FieldElement field,
4499 FunctionElement setter,
4500 AssignmentOperator operator,
4501 Node rhs, 4243 Node rhs,
4502 A arg) { 4244 A arg) {
4503 apply(rhs, arg); 4245 apply(rhs, arg);
4504 return null;
4505 }
4506
4507 @override
4508 R visitTopLevelMethodSetterPostfix(
4509 Send node,
4510 FunctionElement method,
4511 FunctionElement setter,
4512 IncDecOperator operator,
4513 A arg) {
4514 return null;
4515 }
4516
4517 @override
4518 R visitTopLevelMethodSetterPrefix(
4519 Send node,
4520 FunctionElement method,
4521 FunctionElement setter,
4522 IncDecOperator operator,
4523 A arg) {
4524 return null;
4525 }
4526
4527 @override
4528 R visitTopLevelSetterSet(
4529 SendSet node,
4530 FunctionElement setter,
4531 Node rhs,
4532 A arg) {
4533 apply(rhs, arg);
4534 return null; 4246 return null;
4535 } 4247 }
4536 4248
4537 @override 4249 @override
4538 R errorTypeVariableTypeLiteralCompound( 4250 R visitStaticFunctionGet(
4539 Send node, 4251 Send node,
4540 TypeVariableElement element, 4252 MethodElement function,
4541 AssignmentOperator operator,
4542 Node rhs,
4543 A arg) {
4544 apply(rhs, arg);
4545 return null;
4546 }
4547
4548 @override
4549 R visitTypeVariableTypeLiteralGet(
4550 Send node,
4551 TypeVariableElement element,
4552 A arg) { 4253 A arg) {
4553 return null; 4254 return null;
4554 } 4255 }
4555 4256
4556 @override 4257 @override
4557 R visitTypeVariableTypeLiteralInvoke( 4258 R visitStaticFunctionInvoke(
4558 Send node, 4259 Send node,
4559 TypeVariableElement element, 4260 MethodElement function,
4560 NodeList arguments, 4261 NodeList arguments,
4561 CallStructure callStructure, 4262 CallStructure callStructure,
4562 A arg) { 4263 A arg) {
4264 apply(arguments, arg);
4265 return null;
4266 }
4267
4268 @override
4269 R visitStaticFunctionIncompatibleInvoke(
4270 Send node,
4271 MethodElement function,
4272 NodeList arguments,
4273 CallStructure callStructure,
4274 A arg) {
4563 apply(arguments, arg); 4275 apply(arguments, arg);
4564 return null; 4276 return null;
4565 } 4277 }
4566 4278
4567 @override 4279 @override
4568 R errorTypeVariableTypeLiteralPostfix( 4280 R visitStaticGetterGet(
4569 Send node, 4281 Send node,
4570 TypeVariableElement element, 4282 FunctionElement getter,
4571 IncDecOperator operator,
4572 A arg) { 4283 A arg) {
4573 return null; 4284 return null;
4574 } 4285 }
4575 4286
4576 @override 4287 @override
4577 R errorTypeVariableTypeLiteralPrefix( 4288 R visitStaticGetterInvoke(
4578 Send node, 4289 Send node,
4579 TypeVariableElement element, 4290 FunctionElement getter,
4580 IncDecOperator operator, 4291 NodeList arguments,
4292 CallStructure callStructure,
4581 A arg) { 4293 A arg) {
4294 apply(arguments, arg);
4582 return null; 4295 return null;
4583 } 4296 }
4584 4297
4585 @override 4298 @override
4586 R errorTypedefTypeLiteralCompound( 4299 R visitStaticGetterSetterCompound(
4587 Send node, 4300 Send node,
4588 ConstantExpression constant, 4301 FunctionElement getter,
4302 FunctionElement setter,
4589 AssignmentOperator operator, 4303 AssignmentOperator operator,
4590 Node rhs, 4304 Node rhs,
4591 A arg) { 4305 A arg) {
4592 apply(rhs, arg); 4306 apply(rhs, arg);
4593 return null; 4307 return null;
4594 } 4308 }
4595 4309
4596 @override 4310 @override
4597 R visitTypedefTypeLiteralGet( 4311 R visitStaticGetterSetterPostfix(
4598 Send node, 4312 Send node,
4599 ConstantExpression constant, 4313 FunctionElement getter,
4600 A arg) { 4314 FunctionElement setter,
4601 return null;
4602 }
4603
4604 @override
4605 R visitTypedefTypeLiteralInvoke(
4606 Send node,
4607 ConstantExpression constant,
4608 NodeList arguments,
4609 CallStructure callStructure,
4610 A arg) {
4611 apply(arguments, arg);
4612 return null;
4613 }
4614
4615 @override
4616 R errorTypedefTypeLiteralPostfix(
4617 Send node,
4618 ConstantExpression constant,
4619 IncDecOperator operator, 4315 IncDecOperator operator,
4620 A arg) { 4316 A arg) {
4621 return null; 4317 return null;
4622 } 4318 }
4623 4319
4624 @override 4320 @override
4625 R errorTypedefTypeLiteralPrefix( 4321 R visitStaticGetterSetterPrefix(
4626 Send node, 4322 Send node,
4627 ConstantExpression constant, 4323 FunctionElement getter,
4324 FunctionElement setter,
4628 IncDecOperator operator, 4325 IncDecOperator operator,
4629 A arg) { 4326 A arg) {
4630 return null; 4327 return null;
4631 } 4328 }
4632 4329
4633 @override 4330 @override
4634 R visitUnary( 4331 R visitStaticMethodSetterCompound(
4635 Send node, 4332 Send node,
4636 UnaryOperator operator, 4333 FunctionElement method,
4637 Node expression, 4334 FunctionElement setter,
4335 AssignmentOperator operator,
4336 Node rhs,
4638 A arg) { 4337 A arg) {
4639 apply(expression, arg); 4338 apply(rhs, arg);
4640 return null; 4339 return null;
4641 } 4340 }
4642 4341
4643 @override 4342 @override
4644 R errorUnresolvedCompound( 4343 R visitStaticMethodSetterPostfix(
4645 Send node, 4344 Send node,
4646 Element element, 4345 FunctionElement getter,
4346 FunctionElement setter,
4347 IncDecOperator operator,
4348 A arg) {
4349 return null;
4350 }
4351
4352 @override
4353 R visitStaticMethodSetterPrefix(
4354 Send node,
4355 FunctionElement getter,
4356 FunctionElement setter,
4357 IncDecOperator operator,
4358 A arg) {
4359 return null;
4360 }
4361
4362 @override
4363 R visitStaticSetterSet(
4364 SendSet node,
4365 FunctionElement setter,
4366 Node rhs,
4367 A arg) {
4368 apply(rhs, arg);
4369 return null;
4370 }
4371
4372 @override
4373 R visitSuperBinary(
4374 Send node,
4375 FunctionElement function,
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,
4647 AssignmentOperator operator, 4389 AssignmentOperator operator,
4648 Node rhs, 4390 Node rhs,
4649 A arg) { 4391 A arg) {
4650 apply(rhs, arg); 4392 apply(rhs, arg);
4651 return null; 4393 return null;
4652 } 4394 }
4653 4395
4654 @override 4396 @override
4655 R visitUnresolvedGet( 4397 R visitSuperEquals(
4656 Send node, 4398 Send node,
4657 Element element, 4399 FunctionElement function,
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,
4677 IncDecOperator operator,
4678 A arg) {
4679 return null;
4680 }
4681
4682 @override
4683 R errorUnresolvedPrefix(
4684 Send node,
4685 Element element,
4686 IncDecOperator operator,
4687 A arg) {
4688 return null;
4689 }
4690
4691 @override
4692 R errorUnresolvedSet(
4693 Send node,
4694 Element element,
4695 Node rhs,
4696 A arg) {
4697 apply(rhs, arg);
4698 return null;
4699 }
4700
4701 @override
4702 R errorUndefinedBinaryExpression(
4703 Send node,
4704 Node left,
4705 Operator operator,
4706 Node right,
4707 A arg) {
4708 apply(left, arg);
4709 apply(right, arg);
4710 return null;
4711 }
4712
4713 @override
4714 R errorUndefinedUnaryExpression(
4715 Send node,
4716 Operator operator,
4717 Node expression,
4718 A arg) {
4719 apply(expression, arg);
4720 return null;
4721 }
4722
4723 @override
4724 R visitUnresolvedSuperIndexSet(
4725 Send node,
4726 Element element,
4727 Node index,
4728 Node rhs,
4729 A arg) {
4730 apply(index, arg);
4731 apply(rhs, arg);
4732 return null;
4733 }
4734
4735 @override
4736 R visitUnresolvedSuperGetterCompoundIndexSet(
4737 SendSet node,
4738 Element element,
4739 Node index,
4740 AssignmentOperator operator,
4741 Node rhs,
4742 A arg) {
4743 apply(index, arg);
4744 apply(rhs, arg);
4745 return null;
4746 }
4747
4748 @override
4749 R visitUnresolvedSuperSetterCompoundIndexSet(
4750 SendSet node,
4751 MethodElement getter,
4752 Element element,
4753 Node index,
4754 AssignmentOperator operator,
4755 Node rhs,
4756 A arg) {
4757 apply(index, arg);
4758 apply(rhs, arg);
4759 return null;
4760 }
4761
4762 @override
4763 R visitUnresolvedSuperBinary(
4764 Send node,
4765 Element element,
4766 BinaryOperator operator,
4767 Node argument, 4400 Node argument,
4768 A arg) { 4401 A arg) {
4769 apply(argument, arg); 4402 apply(argument, arg);
4770 return null; 4403 return null;
4771 } 4404 }
4772 4405
4773 @override 4406 @override
4774 R visitUnresolvedSuperUnary( 4407 R visitSuperFieldCompound(
4775 Send node, 4408 Send node,
4776 UnaryOperator operator, 4409 FieldElement field,
4777 Element element, 4410 AssignmentOperator operator,
4778 A arg) { 4411 Node rhs,
4779 return null; 4412 A arg) {
4780 } 4413 apply(rhs, arg);
4781 4414 return null;
4782 @override 4415 }
4783 R visitUnresolvedSuperGetterIndexPostfix( 4416
4784 Send node, 4417 @override
4785 Element element, 4418 R visitSuperFieldFieldPostfix(
4786 Node index, 4419 Send node,
4787 IncDecOperator operator, 4420 FieldElement readField,
4788 A arg) { 4421 FieldElement writtenField,
4789 apply(index, arg); 4422 IncDecOperator operator,
4790 return null; 4423 A arg) {
4791 } 4424 return null;
4792 4425 }
4793 @override 4426
4794 R visitUnresolvedSuperSetterIndexPostfix( 4427 @override
4795 Send node, 4428 R visitSuperFieldFieldPrefix(
4796 MethodElement getter, 4429 Send node,
4797 Element element, 4430 FieldElement readField,
4798 Node index, 4431 FieldElement writtenField,
4799 IncDecOperator operator, 4432 IncDecOperator operator,
4800 A arg) { 4433 A arg) {
4801 apply(index, arg); 4434 return null;
4802 return null; 4435 }
4803 } 4436
4804 4437 @override
4805 @override 4438 R visitSuperFieldGet(
4806 R visitUnresolvedSuperGetterIndexPrefix( 4439 Send node,
4807 Send node, 4440 FieldElement field,
4808 Element element, 4441 A arg) {
4809 Node index, 4442 return null;
4810 IncDecOperator operator, 4443 }
4811 A arg) { 4444
4812 apply(index, arg); 4445 @override
4813 return null; 4446 R visitSuperFieldInvoke(
4814 } 4447 Send node,
4815 4448 FieldElement field,
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,
4888 NodeList arguments,
4889 Selector selector,
4890 A arg) {
4891 apply(arguments, arg);
4892 return null;
4893 }
4894
4895 @override
4896 R visitUnresolvedConstructorInvoke(
4897 NewExpression node,
4898 Element constructor,
4899 DartType type,
4900 NodeList arguments,
4901 Selector selector,
4902 A arg) {
4903 apply(arguments, arg);
4904 return null;
4905 }
4906
4907 @override
4908 R visitFactoryConstructorInvoke(
4909 NewExpression node,
4910 ConstructorElement constructor,
4911 InterfaceType type,
4912 NodeList arguments, 4449 NodeList arguments,
4913 CallStructure callStructure, 4450 CallStructure callStructure,
4914 A arg) { 4451 A arg) {
4452 apply(arguments, arg);
4453 return null;
4454 }
4455
4456 @override
4457 R visitSuperFieldPostfix(
4458 Send node,
4459 FieldElement field,
4460 IncDecOperator operator,
4461 A arg) {
4462 return null;
4463 }
4464
4465 @override
4466 R visitSuperFieldPrefix(
4467 Send node,
4468 FieldElement field,
4469 IncDecOperator operator,
4470 A arg) {
4471 return null;
4472 }
4473
4474 @override
4475 R visitSuperFieldSet(
4476 SendSet node,
4477 FieldElement field,
4478 Node rhs,
4479 A arg) {
4480 apply(rhs, arg);
4481 return null;
4482 }
4483
4484 @override
4485 R visitSuperFieldSetterCompound(
4486 Send node,
4487 FieldElement field,
4488 FunctionElement setter,
4489 AssignmentOperator operator,
4490 Node rhs,
4491 A arg) {
4492 apply(rhs, arg);
4493 return null;
4494 }
4495
4496 @override
4497 R visitSuperFieldSetterPostfix(
4498 Send node,
4499 FieldElement field,
4500 FunctionElement setter,
4501 IncDecOperator operator,
4502 A arg) {
4503 return null;
4504 }
4505
4506 @override
4507 R visitSuperFieldSetterPrefix(
4508 Send node,
4509 FieldElement field,
4510 FunctionElement setter,
4511 IncDecOperator operator,
4512 A arg) {
4513 return null;
4514 }
4515
4516 @override
4517 R visitSuperGetterFieldCompound(
4518 Send node,
4519 FunctionElement getter,
4520 FieldElement field,
4521 AssignmentOperator operator,
4522 Node rhs,
4523 A arg) {
4524 apply(rhs, arg);
4525 return null;
4526 }
4527
4528 @override
4529 R visitSuperGetterFieldPostfix(
4530 Send node,
4531 FunctionElement getter,
4532 FieldElement field,
4533 IncDecOperator operator,
4534 A arg) {
4535 return null;
4536 }
4537
4538 @override
4539 R visitSuperGetterFieldPrefix(
4540 Send node,
4541 FunctionElement getter,
4542 FieldElement field,
4543 IncDecOperator operator,
4544 A arg) {
4545 return null;
4546 }
4547
4548 @override
4549 R visitSuperGetterGet(
4550 Send node,
4551 FunctionElement getter,
4552 A arg) {
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,
4574 A arg) {
4575 apply(rhs, arg);
4576 return null;
4577 }
4578
4579 @override
4580 R visitSuperGetterSetterPostfix(
4581 Send node,
4582 FunctionElement getter,
4583 FunctionElement setter,
4584 IncDecOperator operator,
4585 A arg) {
4586 return null;
4587 }
4588
4589 @override
4590 R visitSuperGetterSetterPrefix(
4591 Send node,
4592 FunctionElement getter,
4593 FunctionElement setter,
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,
4604 A arg) {
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,
4615 A arg) {
4616 apply(index, arg);
4617 apply(rhs, arg);
4618 return null;
4619 }
4620
4621 @override
4622 R visitSuperMethodGet(
4623 Send node,
4624 MethodElement method,
4625 A arg) {
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) {
4915 apply(arguments, arg); 4636 apply(arguments, arg);
4916 return null; 4637 return null;
4917 } 4638 }
4918 4639
4919 @override 4640 @override
4920 R visitGenerativeConstructorInvoke( 4641 R visitSuperMethodIncompatibleInvoke(
4921 NewExpression node, 4642 Send node,
4922 ConstructorElement constructor, 4643 MethodElement method,
4923 InterfaceType type,
4924 NodeList arguments, 4644 NodeList arguments,
4925 CallStructure callStructure, 4645 CallStructure callStructure,
4926 A arg) { 4646 A arg) {
4927 apply(arguments, arg); 4647 apply(arguments, arg);
4928 return null; 4648 return null;
4929 } 4649 }
4930 4650
4931 @override 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,
4688 A arg) {
4689 apply(argument, arg);
4690 return null;
4691 }
4692
4693 @override
4694 R visitSuperSetterSet(
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,
4706 UnaryOperator operator,
4707 FunctionElement function,
4708 A arg) {
4709 return null;
4710 }
4711
4712 @override
4713 R visitThisGet(Identifier node, A arg) {
4714 return null;
4715 }
4716
4717 @override
4718 R visitThisInvoke(
4719 Send node,
4720 NodeList arguments,
4721 CallStructure callStructure,
4722 A arg) {
4723 apply(arguments, arg);
4724 return null;
4725 }
4726
4727 @override
4728 R visitThisPropertyCompound(
4729 Send node,
4730 AssignmentOperator operator,
4731 Node rhs,
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,
4751 Selector selector,
4752 A arg) {
4753 apply(arguments, arg);
4754 return null;
4755 }
4756
4757 @override
4758 R visitThisPropertyPostfix(
4759 Send node,
4760 IncDecOperator operator,
4761 Selector getterSelector,
4762 Selector setterSelector,
4763 A arg) {
4764 return null;
4765 }
4766
4767 @override
4768 R visitThisPropertyPrefix(
4769 Send node,
4770 IncDecOperator operator,
4771 Selector getterSelector,
4772 Selector setterSelector,
4773 A arg) {
4774 return null;
4775 }
4776
4777 @override
4778 R visitThisPropertySet(
4779 SendSet node,
4780 Selector selector,
4781 Node rhs,
4782 A arg) {
4783 apply(rhs, arg);
4784 return null;
4785 }
4786
4787 @override
4788 R visitTopLevelFieldCompound(
4789 Send node,
4790 FieldElement field,
4791 AssignmentOperator operator,
4792 Node rhs,
4793 A arg) {
4794 apply(rhs, arg);
4795 return null;
4796 }
4797
4798 @override
4799 R visitTopLevelFieldGet(
4800 Send node,
4801 FieldElement field,
4802 A arg) {
4803 return null;
4804 }
4805
4806 @override
4807 R visitTopLevelFieldInvoke(
4808 Send node,
4809 FieldElement field,
4810 NodeList arguments,
4811 CallStructure callStructure,
4812 A arg) {
4813 apply(arguments, arg);
4814 return null;
4815 }
4816
4817 @override
4818 R visitTopLevelFieldPostfix(
4819 Send node,
4820 FieldElement field,
4821 IncDecOperator operator,
4822 A arg) {
4823 return null;
4824 }
4825
4826 @override
4827 R visitTopLevelFieldPrefix(
4828 Send node,
4829 FieldElement field,
4830 IncDecOperator operator,
4831 A arg) {
4832 return null;
4833 }
4834
4835 @override
4836 R visitTopLevelFieldSet(
4837 SendSet node,
4838 FieldElement field,
4839 Node rhs,
4840 A arg) {
4841 apply(rhs, arg);
4842 return null;
4843 }
4844
4845 @override
4846 R visitTopLevelFunctionGet(
4847 Send node,
4848 MethodElement function,
4849 A arg) {
4850 return null;
4851 }
4852
4853 @override
4854 R visitTopLevelFunctionInvoke(
4855 Send node,
4856 MethodElement function,
4857 NodeList arguments,
4858 CallStructure callStructure,
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,
4961 FunctionElement setter,
4962 Node rhs,
4963 A arg) {
4964 apply(rhs, arg);
4965 return null;
4966 }
4967
4968 @override
4969 R visitTypeVariableTypeLiteralCompound(
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,
5077 Element element,
5078 AssignmentOperator operator,
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,
5099 A arg) {
5100 apply(arguments, arg);
5101 return null;
5102 }
5103
5104 @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
4932 R visitRedirectingFactoryConstructorInvoke( 5402 R visitRedirectingFactoryConstructorInvoke(
4933 NewExpression node, 5403 NewExpression node,
4934 ConstructorElement constructor, 5404 ConstructorElement constructor,
4935 InterfaceType type, 5405 InterfaceType type,
4936 ConstructorElement effectiveTarget, 5406 ConstructorElement effectiveTarget,
4937 InterfaceType effectiveTargetType, 5407 InterfaceType effectiveTargetType,
4938 NodeList arguments, 5408 NodeList arguments,
4939 CallStructure callStructure, 5409 CallStructure callStructure,
4940 A arg) { 5410 A arg) {
4941 apply(arguments, arg); 5411 apply(arguments, arg);
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
4982 R errorNonConstantConstructorInvoke( 5452 R errorNonConstantConstructorInvoke(
4983 NewExpression node, 5453 NewExpression node,
4984 Element element, 5454 Element element,
4985 DartType type, 5455 DartType type,
4986 NodeList arguments, 5456 NodeList arguments,
4987 CallStructure callStructure, 5457 CallStructure callStructure,
4988 A arg) { 5458 A arg) {
4989 apply(arguments, arg); 5459 apply(arguments, arg);
4990 return null; 5460 return null;
4991 } 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 }
4992 } 5880 }
4993 5881
4994 /// [SemanticDeclarationVisitor] that visits subnodes. 5882 /// [SemanticDeclarationVisitor] that visits subnodes.
4995 class TraversalDeclarationMixin<R, A> 5883 class TraversalDeclarationMixin<R, A>
4996 implements SemanticDeclarationVisitor<R, A> { 5884 implements SemanticDeclarationVisitor<R, A> {
4997 @override 5885 @override
4998 R apply(Node node, A arg) { 5886 R apply(Node node, A arg) {
4999 throw new UnimplementedError("TraversalMixin.apply unimplemented"); 5887 throw new UnimplementedError("TraversalMixin.apply unimplemented");
5000 } 5888 }
5001 5889
(...skipping 454 matching lines...) Expand 10 before | Expand all | Expand 10 after
5456 throw new SpannableAssertionFailure(spannable, message); 6344 throw new SpannableAssertionFailure(spannable, message);
5457 } 6345 }
5458 6346
5459 @override 6347 @override
5460 R visitNode(Node node) { 6348 R visitNode(Node node) {
5461 node.visitChildren(this); 6349 node.visitChildren(this);
5462 return null; 6350 return null;
5463 } 6351 }
5464 } 6352 }
5465 6353
5466 /// Mixin that groups all `visitStaticX` and `visitTopLevelX` method by 6354 /// Mixin that groups all non-compound `visitStaticX` and `visitTopLevelX`
5467 /// delegating calls to `handleStaticX` methods. 6355 /// method by delegating calls to `handleStaticX` methods.
5468 /// 6356 ///
5469 /// This mixin is useful for the cases where both top level members and static 6357 /// This mixin is useful for the cases where both top level members and static
5470 /// class members are handled uniformly. 6358 /// class members are handled uniformly.
5471 abstract class BaseImplementationOfStaticsMixin<R, A> 6359 abstract class BaseImplementationOfStaticsMixin<R, A>
5472 implements SemanticSendVisitor<R, A> { 6360 implements SemanticSendVisitor<R, A> {
5473 R handleStaticFieldCompound(
5474 Send node,
5475 FieldElement field,
5476 AssignmentOperator operator,
5477 Node rhs,
5478 A arg);
5479
5480 R handleStaticFieldGet( 6361 R handleStaticFieldGet(
5481 Send node, 6362 Send node,
5482 FieldElement field, 6363 FieldElement field,
5483 A arg); 6364 A arg);
5484 6365
5485 R handleStaticFieldInvoke( 6366 R handleStaticFieldInvoke(
5486 Send node, 6367 Send node,
5487 FieldElement field, 6368 FieldElement field,
5488 NodeList arguments, 6369 NodeList arguments,
5489 CallStructure callStructure, 6370 CallStructure callStructure,
5490 A arg); 6371 A arg);
5491 6372
5492 R handleStaticFieldPostfixPrefix(
5493 Send node,
5494 FieldElement field,
5495 IncDecOperator operator,
5496 A arg,
5497 {bool isPrefix});
5498
5499 R handleStaticFieldSet( 6373 R handleStaticFieldSet(
5500 SendSet node, 6374 SendSet node,
5501 FieldElement field, 6375 FieldElement field,
5502 Node rhs, 6376 Node rhs,
5503 A arg); 6377 A arg);
5504 6378
5505 R handleStaticFunctionGet( 6379 R handleStaticFunctionGet(
5506 Send node, 6380 Send node,
5507 MethodElement function, 6381 MethodElement function,
5508 A arg); 6382 A arg);
(...skipping 17 matching lines...) Expand all
5526 FunctionElement getter, 6400 FunctionElement getter,
5527 A arg); 6401 A arg);
5528 6402
5529 R handleStaticGetterInvoke( 6403 R handleStaticGetterInvoke(
5530 Send node, 6404 Send node,
5531 FunctionElement getter, 6405 FunctionElement getter,
5532 NodeList arguments, 6406 NodeList arguments,
5533 CallStructure callStructure, 6407 CallStructure callStructure,
5534 A arg); 6408 A arg);
5535 6409
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
5568 R handleStaticSetterSet( 6410 R handleStaticSetterSet(
5569 SendSet node, 6411 SendSet node,
5570 FunctionElement setter, 6412 FunctionElement setter,
5571 Node rhs, 6413 Node rhs,
5572 A arg); 6414 A arg);
5573 6415
5574 @override 6416 @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
5585 R visitStaticFieldGet( 6417 R visitStaticFieldGet(
5586 Send node, 6418 Send node,
5587 FieldElement field, 6419 FieldElement field,
5588 A arg) { 6420 A arg) {
5589 return handleStaticFieldGet(node, field, arg); 6421 return handleStaticFieldGet(node, field, arg);
5590 } 6422 }
5591 6423
5592 @override 6424 @override
5593 R visitStaticFieldInvoke( 6425 R visitStaticFieldInvoke(
5594 Send node, 6426 Send node,
5595 FieldElement field, 6427 FieldElement field,
5596 NodeList arguments, 6428 NodeList arguments,
5597 CallStructure callStructure, 6429 CallStructure callStructure,
5598 A arg) { 6430 A arg) {
5599 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg); 6431 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
5600 } 6432 }
5601 6433
5602 @override 6434 @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
5623 R visitStaticFieldSet( 6435 R visitStaticFieldSet(
5624 SendSet node, 6436 SendSet node,
5625 FieldElement field, 6437 FieldElement field,
5626 Node rhs, 6438 Node rhs,
5627 A arg) { 6439 A arg) {
5628 return handleStaticFieldSet(node, field, rhs, arg); 6440 return handleStaticFieldSet(node, field, rhs, arg);
5629 } 6441 }
5630 6442
5631 @override 6443 @override
5632 R visitStaticFunctionGet( 6444 R visitStaticFunctionGet(
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
5671 Send node, 6483 Send node,
5672 FunctionElement getter, 6484 FunctionElement getter,
5673 NodeList arguments, 6485 NodeList arguments,
5674 CallStructure callStructure, 6486 CallStructure callStructure,
5675 A arg) { 6487 A arg) {
5676 return handleStaticGetterInvoke( 6488 return handleStaticGetterInvoke(
5677 node, getter, arguments, callStructure, arg); 6489 node, getter, arguments, callStructure, arg);
5678 } 6490 }
5679 6491
5680 @override 6492 @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
5749 R visitStaticSetterSet( 6493 R visitStaticSetterSet(
5750 SendSet node, 6494 SendSet node,
5751 FunctionElement setter, 6495 FunctionElement setter,
5752 Node rhs, 6496 Node rhs,
5753 A arg) { 6497 A arg) {
5754 return handleStaticSetterSet(node, setter, rhs, arg); 6498 return handleStaticSetterSet(node, setter, rhs, arg);
5755 } 6499 }
5756 6500
5757 @override 6501 @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
5768 R visitTopLevelFieldGet( 6502 R visitTopLevelFieldGet(
5769 Send node, 6503 Send node,
5770 FieldElement field, 6504 FieldElement field,
5771 A arg) { 6505 A arg) {
5772 return handleStaticFieldGet(node, field, arg); 6506 return handleStaticFieldGet(node, field, arg);
5773 } 6507 }
5774 6508
5775 @override 6509 @override
5776 R visitTopLevelFieldInvoke( 6510 R visitTopLevelFieldInvoke(
5777 Send node, 6511 Send node,
5778 FieldElement field, 6512 FieldElement field,
5779 NodeList arguments, 6513 NodeList arguments,
5780 CallStructure callStructure, 6514 CallStructure callStructure,
5781 A arg) { 6515 A arg) {
5782 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg); 6516 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
5783 } 6517 }
5784 6518
5785 @override 6519 @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
5806 R visitTopLevelFieldSet( 6520 R visitTopLevelFieldSet(
5807 SendSet node, 6521 SendSet node,
5808 FieldElement field, 6522 FieldElement field,
5809 Node rhs, 6523 Node rhs,
5810 A arg) { 6524 A arg) {
5811 return handleStaticFieldSet(node, field, rhs, arg); 6525 return handleStaticFieldSet(node, field, rhs, arg);
5812 } 6526 }
5813 6527
5814 @override 6528 @override
5815 R visitTopLevelFunctionGet( 6529 R visitTopLevelFunctionGet(
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
5854 Send node, 6568 Send node,
5855 FunctionElement getter, 6569 FunctionElement getter,
5856 NodeList arguments, 6570 NodeList arguments,
5857 CallStructure callStructure, 6571 CallStructure callStructure,
5858 A arg) { 6572 A arg) {
5859 return handleStaticGetterInvoke( 6573 return handleStaticGetterInvoke(
5860 node, getter, arguments, callStructure, arg); 6574 node, getter, arguments, callStructure, arg);
5861 } 6575 }
5862 6576
5863 @override 6577 @override
5864 R visitTopLevelGetterSetterCompound( 6578 R visitTopLevelSetterSet(
6579 SendSet node,
6580 FunctionElement setter,
6581 Node rhs,
6582 A arg) {
6583 return handleStaticSetterSet(node, setter, rhs, arg);
6584 }
6585 }
6586
6587 /// Mixin that groups all compounds visitors `visitStaticX` and `visitTopLevelX`
6588 /// method by delegating calls to `handleStaticX` 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(
5865 Send node, 6732 Send node,
5866 FunctionElement getter, 6733 FunctionElement getter,
5867 FunctionElement setter, 6734 FunctionElement setter,
5868 AssignmentOperator operator, 6735 AssignmentOperator operator,
5869 Node rhs, 6736 Node rhs,
5870 A arg) { 6737 A arg) {
5871 return handleStaticGetterSetterCompound( 6738 return handleStaticGetterSetterCompound(
5872 node, getter, setter, operator, rhs, arg); 6739 node, getter, setter, operator, rhs, arg);
5873 } 6740 }
5874 6741
5875 @override 6742 @override
5876 R visitTopLevelGetterSetterPostfix( 6743 R visitStaticGetterSetterPostfix(
5877 Send node, 6744 Send node,
5878 FunctionElement getter, 6745 FunctionElement getter,
5879 FunctionElement setter, 6746 FunctionElement setter,
5880 IncDecOperator operator, 6747 IncDecOperator operator,
5881 A arg) { 6748 A arg) {
5882 return handleStaticGetterSetterPostfixPrefix( 6749 return handleStaticGetterSetterPostfixPrefix(
5883 node, getter, setter, operator, arg, isPrefix: false); 6750 node, getter, setter, operator, arg, isPrefix: false);
5884 } 6751 }
5885 6752
5886 @override 6753 @override
5887 R visitTopLevelGetterSetterPrefix( 6754 R visitStaticGetterSetterPrefix(
5888 Send node, 6755 Send node,
5889 FunctionElement getter, 6756 FunctionElement getter,
5890 FunctionElement setter, 6757 FunctionElement setter,
5891 IncDecOperator operator, 6758 IncDecOperator operator,
5892 A arg) { 6759 A arg) {
5893 return handleStaticGetterSetterPostfixPrefix( 6760 return handleStaticGetterSetterPostfixPrefix(
5894 node, getter, setter, operator, arg, isPrefix: true); 6761 node, getter, setter, operator, arg, isPrefix: true);
5895 } 6762 }
5896 6763
5897 @override 6764 @override
5898 R visitTopLevelMethodSetterCompound( 6765 R visitStaticMethodSetterCompound(
5899 Send node, 6766 Send node,
5900 FunctionElement method, 6767 FunctionElement method,
5901 FunctionElement setter, 6768 FunctionElement setter,
5902 AssignmentOperator operator, 6769 AssignmentOperator operator,
5903 Node rhs, 6770 Node rhs,
5904 A arg) { 6771 A arg) {
5905 return handleStaticMethodSetterCompound( 6772 return handleStaticMethodSetterCompound(
5906 node, method, setter, operator, rhs, arg); 6773 node, method, setter, operator, rhs, arg);
5907 } 6774 }
5908 6775
5909 @override 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
5910 R visitTopLevelMethodSetterPostfix( 6875 R visitTopLevelMethodSetterPostfix(
5911 Send node, 6876 Send node,
5912 FunctionElement method, 6877 FunctionElement method,
5913 FunctionElement setter, 6878 FunctionElement setter,
5914 IncDecOperator operator, 6879 IncDecOperator operator,
5915 A arg) { 6880 A arg) {
5916 return handleStaticMethodSetterPostfixPrefix( 6881 return handleStaticMethodSetterPostfixPrefix(
5917 node, method, setter, operator, arg, isPrefix: false); 6882 node, method, setter, operator, arg, isPrefix: false);
5918 } 6883 }
5919 6884
5920 @override 6885 @override
5921 R visitTopLevelMethodSetterPrefix( 6886 R visitTopLevelMethodSetterPrefix(
5922 Send node, 6887 Send node,
5923 FunctionElement method, 6888 FunctionElement method,
5924 FunctionElement setter, 6889 FunctionElement setter,
5925 IncDecOperator operator, 6890 IncDecOperator operator,
5926 A arg) { 6891 A arg) {
5927 return handleStaticMethodSetterPostfixPrefix( 6892 return handleStaticMethodSetterPostfixPrefix(
5928 node, method, setter, operator, arg, isPrefix: true); 6893 node, method, setter, operator, arg, isPrefix: true);
5929 } 6894 }
5930 6895
5931 @override 6896 @override
5932 R visitTopLevelSetterSet( 6897 R visitFinalStaticFieldCompound(
5933 SendSet node, 6898 Send node,
5934 FunctionElement setter, 6899 FieldElement field,
5935 Node rhs, 6900 AssignmentOperator operator,
5936 A arg) { 6901 Node rhs,
5937 return handleStaticSetterSet(node, setter, rhs, arg); 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);
5938 } 7024 }
5939 } 7025 }
5940 7026
5941 /// Mixin that groups all `visitLocalX` and `visitParameterX` method by 7027 /// Mixin that groups all non-compound `visitLocalX` and `visitParameterX`
5942 /// delegating calls to `handleLocalX` methods. 7028 /// methods by delegating calls to `handleLocalX` methods.
5943 /// 7029 ///
5944 /// This mixin is useful for the cases where both parameters, local variables, 7030 /// This mixin is useful for the cases where both parameters, local variables,
5945 /// and local functions, captured or not, are handled uniformly. 7031 /// and local functions, captured or not, are handled uniformly.
5946 abstract class BaseImplementationOfLocalsMixin<R, A> 7032 abstract class BaseImplementationOfLocalsMixin<R, A>
5947 implements SemanticSendVisitor<R, A> { 7033 implements SemanticSendVisitor<R, A> {
5948 R handleLocalCompound(
5949 Send node,
5950 LocalElement element,
5951 AssignmentOperator operator,
5952 Node rhs,
5953 A arg);
5954
5955 R handleLocalGet( 7034 R handleLocalGet(
5956 Send node, 7035 Send node,
5957 LocalElement element, 7036 LocalElement element,
5958 A arg); 7037 A arg);
5959 7038
5960 R handleLocalInvoke( 7039 R handleLocalInvoke(
5961 Send node, 7040 Send node,
5962 LocalElement element, 7041 LocalElement element,
5963 NodeList arguments, 7042 NodeList arguments,
5964 CallStructure callStructure, 7043 CallStructure callStructure,
5965 A arg); 7044 A arg);
5966 7045
5967 R handleLocalPostfixPrefix(
5968 Send node,
5969 LocalElement element,
5970 IncDecOperator operator,
5971 A arg,
5972 {bool isPrefix});
5973
5974 R handleLocalSet( 7046 R handleLocalSet(
5975 SendSet node, 7047 SendSet node,
5976 LocalElement element, 7048 LocalElement element,
5977 Node rhs, 7049 Node rhs,
5978 A arg); 7050 A arg);
5979 7051
5980 @override 7052 @override
5981 R visitLocalFunctionGet( 7053 R visitLocalFunctionGet(
5982 Send node, 7054 Send node,
5983 LocalFunctionElement function, 7055 LocalFunctionElement function,
5984 A arg) { 7056 A arg) {
5985 return handleLocalGet(node, function, arg); 7057 return handleLocalGet(node, function, arg);
5986 } 7058 }
5987 7059
5988 @override 7060 @override
5989 R visitLocalFunctionInvoke( 7061 R visitLocalFunctionInvoke(
5990 Send node, 7062 Send node,
5991 LocalFunctionElement function, 7063 LocalFunctionElement function,
5992 NodeList arguments, 7064 NodeList arguments,
5993 CallStructure callStructure, 7065 CallStructure callStructure,
5994 A arg) { 7066 A arg) {
5995 return handleLocalInvoke(node, function, arguments, callStructure, arg); 7067 return handleLocalInvoke(node, function, arguments, callStructure, arg);
5996 } 7068 }
5997 7069
5998 @override 7070 @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
6009 R visitLocalVariableGet( 7071 R visitLocalVariableGet(
6010 Send node, 7072 Send node,
6011 LocalVariableElement variable, 7073 LocalVariableElement variable,
6012 A arg) { 7074 A arg) {
6013 return handleLocalGet(node, variable, arg); 7075 return handleLocalGet(node, variable, arg);
6014 } 7076 }
6015 7077
6016 @override 7078 @override
6017 R visitLocalVariableInvoke( 7079 R visitLocalVariableInvoke(
6018 Send node, 7080 Send node,
6019 LocalVariableElement variable, 7081 LocalVariableElement variable,
6020 NodeList arguments, 7082 NodeList arguments,
6021 CallStructure callStructure, 7083 CallStructure callStructure,
6022 A arg) { 7084 A arg) {
6023 return handleLocalInvoke(node, variable, arguments, callStructure, arg); 7085 return handleLocalInvoke(node, variable, arguments, callStructure, arg);
6024 } 7086 }
6025 7087
6026 @override 7088 @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
6047 R visitLocalVariableSet( 7089 R visitLocalVariableSet(
6048 SendSet node, 7090 SendSet node,
6049 LocalVariableElement variable, 7091 LocalVariableElement variable,
6050 Node rhs, 7092 Node rhs,
6051 A arg) { 7093 A arg) {
6052 return handleLocalSet(node, variable, rhs, arg); 7094 return handleLocalSet(node, variable, rhs, arg);
6053 } 7095 }
6054 7096
6055 @override 7097 @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
6066 R visitParameterGet( 7098 R visitParameterGet(
6067 Send node, 7099 Send node,
6068 ParameterElement parameter, 7100 ParameterElement parameter,
6069 A arg) { 7101 A arg) {
6070 return handleLocalGet(node, parameter, arg); 7102 return handleLocalGet(node, parameter, arg);
6071 } 7103 }
6072 7104
6073 @override 7105 @override
6074 R visitParameterInvoke( 7106 R visitParameterInvoke(
6075 Send node, 7107 Send node,
6076 ParameterElement parameter, 7108 ParameterElement parameter,
6077 NodeList arguments, 7109 NodeList arguments,
6078 CallStructure callStructure, 7110 CallStructure callStructure,
6079 A arg) { 7111 A arg) {
6080 return handleLocalInvoke(node, parameter, arguments, callStructure, arg); 7112 return handleLocalInvoke(node, parameter, arguments, callStructure, arg);
6081 } 7113 }
6082 7114
6083 @override 7115 @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
6104 R visitParameterSet( 7116 R visitParameterSet(
6105 SendSet node, 7117 SendSet node,
6106 ParameterElement parameter, 7118 ParameterElement parameter,
6107 Node rhs, 7119 Node rhs,
6108 A arg) { 7120 A arg) {
6109 return handleLocalSet(node, parameter, rhs, arg); 7121 return handleLocalSet(node, parameter, rhs, arg);
6110 } 7122 }
6111 } 7123 }
6112 7124
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
6113 /// Mixin that groups all `visitConstantX` and `visitXTypeLiteralY` methods for 7207 /// Mixin that groups all `visitConstantX` and `visitXTypeLiteralY` methods for
6114 /// constant type literals by delegating calls to `handleConstantX` methods. 7208 /// constant type literals by delegating calls to `handleConstantX` methods.
6115 /// 7209 ///
6116 /// This mixin is useful for the cases where expressions on constants are 7210 /// This mixin is useful for the cases where expressions on constants are
6117 /// handled uniformly. 7211 /// handled uniformly.
6118 abstract class BaseImplementationOfConstantsMixin<R, A> 7212 abstract class BaseImplementationOfConstantsMixin<R, A>
6119 implements SemanticSendVisitor<R, A> { 7213 implements SemanticSendVisitor<R, A> {
6120 R handleConstantGet( 7214 R handleConstantGet(
6121 Node node, 7215 Node node,
6122 ConstantExpression constant, 7216 ConstantExpression constant,
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after
6203 R visitTypedefTypeLiteralInvoke( 7297 R visitTypedefTypeLiteralInvoke(
6204 Send node, 7298 Send node,
6205 ConstantExpression constant, 7299 ConstantExpression constant,
6206 NodeList arguments, 7300 NodeList arguments,
6207 CallStructure callStructure, 7301 CallStructure callStructure,
6208 A arg) { 7302 A arg) {
6209 return handleConstantInvoke(node, constant, arguments, callStructure, arg); 7303 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
6210 } 7304 }
6211 } 7305 }
6212 7306
6213 /// Mixin that groups all `visitDynamicPropertyX` and `visitThisPropertyY` 7307 /// Mixin that groups all non-compound `visitDynamicPropertyX` and
6214 /// methods for by delegating calls to `handleDynamicX` methods, providing 7308 /// `visitThisPropertyY` methods for by delegating calls to `handleDynamicX`
6215 /// `null` as the receiver for the this properties. 7309 /// methods, providing `null` as the receiver for the this properties.
6216 /// 7310 ///
6217 /// This mixin is useful for the cases where dynamic and this properties are 7311 /// This mixin is useful for the cases where dynamic and this properties are
6218 /// handled uniformly. 7312 /// handled uniformly.
6219 abstract class BaseImplementationOfDynamicsMixin<R, A> 7313 abstract class BaseImplementationOfDynamicsMixin<R, A>
6220 implements SemanticSendVisitor<R, A> { 7314 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
6230 R handleDynamicGet( 7315 R handleDynamicGet(
6231 Send node, 7316 Send node,
6232 Node receiver, 7317 Node receiver,
6233 Selector selector, 7318 Selector selector,
6234 A arg); 7319 A arg);
6235 7320
6236 R handleDynamicInvoke( 7321 R handleDynamicInvoke(
6237 Send node, 7322 Send node,
6238 Node receiver, 7323 Node receiver,
6239 NodeList arguments, 7324 NodeList arguments,
6240 Selector selector, 7325 Selector selector,
6241 A arg); 7326 A arg);
6242 7327
7328 R handleDynamicSet(
7329 SendSet node,
7330 Node receiver,
7331 Selector selector,
7332 Node rhs,
7333 A arg);
7334
7335 @override
7336 R visitDynamicPropertyGet(
7337 Send node,
7338 Node receiver,
7339 Selector selector,
7340 A arg) {
7341 return handleDynamicGet(node, receiver, selector, arg);
7342 }
7343
7344 @override
7345 R visitDynamicPropertyInvoke(
7346 Send node,
7347 Node receiver,
7348 NodeList arguments,
7349 Selector selector,
7350 A arg) {
7351 return handleDynamicInvoke(node, receiver, arguments, selector, arg);
7352 }
7353
7354 @override
7355 R visitDynamicPropertySet(
7356 SendSet node,
7357 Node receiver,
7358 Selector selector,
7359 Node rhs,
7360 A arg) {
7361 return handleDynamicSet(node, receiver, selector, rhs, arg);
7362 }
7363
7364 @override
7365 R visitThisPropertyGet(
7366 Send node,
7367 Selector selector,
7368 A arg) {
7369 return handleDynamicGet(node, null, selector, arg);
7370 }
7371
7372 @override
7373 R visitThisPropertyInvoke(
7374 Send node,
7375 NodeList arguments,
7376 Selector selector,
7377 A arg) {
7378 return handleDynamicInvoke(node, null, arguments, selector, arg);
7379 }
7380
7381 @override
7382 R visitThisPropertySet(
7383 SendSet node,
7384 Selector selector,
7385 Node rhs,
7386 A arg) {
7387 return handleDynamicSet(node, null, selector, rhs, arg);
7388 }
7389 }
7390
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
6243 R handleDynamicPostfixPrefix( 7408 R handleDynamicPostfixPrefix(
6244 Send node, 7409 Send node,
6245 Node receiver, 7410 Node receiver,
6246 IncDecOperator operator, 7411 IncDecOperator operator,
6247 Selector getterSelector, 7412 Selector getterSelector,
6248 Selector setterSelector, 7413 Selector setterSelector,
6249 A arg, 7414 A arg,
6250 {bool isPrefix}); 7415 {bool isPrefix});
6251 7416
6252 R handleDynamicSet(
6253 SendSet node,
6254 Node receiver,
6255 Selector selector,
6256 Node rhs,
6257 A arg);
6258
6259 R handleDynamicIndexPostfixPrefix( 7417 R handleDynamicIndexPostfixPrefix(
6260 Send node, 7418 Send node,
6261 Node receiver, 7419 Node receiver,
6262 Node index, 7420 Node index,
6263 IncDecOperator operator, 7421 IncDecOperator operator,
6264 A arg, 7422 A arg,
6265 {bool isPrefix}); 7423 {bool isPrefix});
6266 7424
6267 @override 7425 @override
6268 R visitDynamicPropertyCompound( 7426 R visitDynamicPropertyCompound(
6269 Send node, 7427 Send node,
6270 Node receiver, 7428 Node receiver,
6271 AssignmentOperator operator, 7429 AssignmentOperator operator,
6272 Node rhs, 7430 Node rhs,
6273 Selector getterSelector, 7431 Selector getterSelector,
6274 Selector setterSelector, 7432 Selector setterSelector,
6275 A arg) { 7433 A arg) {
6276 return handleDynamicCompound( 7434 return handleDynamicCompound(
6277 node, receiver, operator, rhs, getterSelector, setterSelector, arg); 7435 node, receiver, operator, rhs, getterSelector, setterSelector, arg);
6278 } 7436 }
6279 7437
6280 @override 7438 @override
6281 R visitDynamicPropertyGet(
6282 Send node,
6283 Node receiver,
6284 Selector selector,
6285 A arg) {
6286 return handleDynamicGet(node, receiver, selector, arg);
6287 }
6288
6289 @override
6290 R visitDynamicPropertyInvoke(
6291 Send node,
6292 Node receiver,
6293 NodeList arguments,
6294 Selector selector,
6295 A arg) {
6296 return handleDynamicInvoke(node, receiver, arguments, selector, arg);
6297 }
6298
6299 @override
6300 R visitDynamicPropertyPostfix( 7439 R visitDynamicPropertyPostfix(
6301 Send node, 7440 Send node,
6302 Node receiver, 7441 Node receiver,
6303 IncDecOperator operator, 7442 IncDecOperator operator,
6304 Selector getterSelector, 7443 Selector getterSelector,
6305 Selector setterSelector, 7444 Selector setterSelector,
6306 A arg) { 7445 A arg) {
6307 return handleDynamicPostfixPrefix( 7446 return handleDynamicPostfixPrefix(
6308 node, receiver, operator, 7447 node, receiver, operator,
6309 getterSelector, setterSelector, arg, isPrefix: false); 7448 getterSelector, setterSelector, arg, isPrefix: false);
6310 } 7449 }
6311 7450
6312 @override 7451 @override
6313 R visitDynamicPropertyPrefix( 7452 R visitDynamicPropertyPrefix(
6314 Send node, 7453 Send node,
6315 Node receiver, 7454 Node receiver,
6316 IncDecOperator operator, 7455 IncDecOperator operator,
6317 Selector getterSelector, 7456 Selector getterSelector,
6318 Selector setterSelector, 7457 Selector setterSelector,
6319 A arg) { 7458 A arg) {
6320 return handleDynamicPostfixPrefix( 7459 return handleDynamicPostfixPrefix(
6321 node, receiver, operator, 7460 node, receiver, operator,
6322 getterSelector, setterSelector, arg, isPrefix: true); 7461 getterSelector, setterSelector, arg, isPrefix: true);
6323 } 7462 }
6324 7463
6325 @override 7464 @override
6326 R visitDynamicPropertySet(
6327 SendSet node,
6328 Node receiver,
6329 Selector selector,
6330 Node rhs,
6331 A arg) {
6332 return handleDynamicSet(node, receiver, selector, rhs, arg);
6333 }
6334
6335 @override
6336 R visitThisPropertyCompound( 7465 R visitThisPropertyCompound(
6337 Send node, 7466 Send node,
6338 AssignmentOperator operator, 7467 AssignmentOperator operator,
6339 Node rhs, 7468 Node rhs,
6340 Selector getterSelector, 7469 Selector getterSelector,
6341 Selector setterSelector, 7470 Selector setterSelector,
6342 A arg) { 7471 A arg) {
6343 return handleDynamicCompound( 7472 return handleDynamicCompound(
6344 node, null, operator, rhs, getterSelector, setterSelector, arg); 7473 node, null, operator, rhs, getterSelector, setterSelector, arg);
6345 } 7474 }
6346 7475
6347 @override 7476 @override
6348 R visitThisPropertyGet(
6349 Send node,
6350 Selector selector,
6351 A arg) {
6352 return handleDynamicGet(node, null, selector, arg);
6353 }
6354
6355 @override
6356 R visitThisPropertyInvoke(
6357 Send node,
6358 NodeList arguments,
6359 Selector selector,
6360 A arg) {
6361 return handleDynamicInvoke(node, null, arguments, selector, arg);
6362 }
6363
6364 @override
6365 R visitThisPropertyPostfix( 7477 R visitThisPropertyPostfix(
6366 Send node, 7478 Send node,
6367 IncDecOperator operator, 7479 IncDecOperator operator,
6368 Selector getterSelector, 7480 Selector getterSelector,
6369 Selector setterSelector, 7481 Selector setterSelector,
6370 A arg) { 7482 A arg) {
6371 return handleDynamicPostfixPrefix( 7483 return handleDynamicPostfixPrefix(
6372 node, null, operator, 7484 node, null, operator,
6373 getterSelector, setterSelector, arg, isPrefix: false); 7485 getterSelector, setterSelector, arg, isPrefix: false);
6374 } 7486 }
6375 7487
6376 @override 7488 @override
6377 R visitThisPropertyPrefix( 7489 R visitThisPropertyPrefix(
6378 Send node, 7490 Send node,
6379 IncDecOperator operator, 7491 IncDecOperator operator,
6380 Selector getterSelector, 7492 Selector getterSelector,
6381 Selector setterSelector, 7493 Selector setterSelector,
6382 A arg) { 7494 A arg) {
6383 return handleDynamicPostfixPrefix( 7495 return handleDynamicPostfixPrefix(
6384 node, null, operator, 7496 node, null, operator,
6385 getterSelector, setterSelector, arg, isPrefix: true); 7497 getterSelector, setterSelector, arg, isPrefix: true);
6386 } 7498 }
6387 7499
6388 @override 7500 @override
6389 R visitThisPropertySet( 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(
6390 SendSet node, 7606 SendSet node,
6391 Selector selector, 7607 Element getter,
6392 Node rhs, 7608 CompoundGetter getterKind,
6393 A arg) { 7609 Element setter,
6394 return handleDynamicSet(node, null, selector, rhs, arg); 7610 CompoundSetter setterKind,
6395 } 7611 CompoundRhs rhs,
6396 7612 A arg);
6397 @override 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
6398 R visitIndexPostfix( 9586 R visitIndexPostfix(
6399 Send node, 9587 Send node,
6400 Node receiver, 9588 Node receiver,
6401 Node index, 9589 Node index,
6402 IncDecOperator operator, 9590 IncDecOperator operator,
6403 A arg) { 9591 A arg) {
6404 return handleDynamicIndexPostfixPrefix( 9592 return handleIndexCompounds(
6405 node, receiver, index, operator, arg, isPrefix: false); 9593 node, receiver, index,
9594 new IncDecCompound(CompoundKind.POSTFIX, operator), arg);
6406 } 9595 }
6407 9596
6408 @override 9597 @override
6409 R visitIndexPrefix( 9598 R visitIndexPrefix(
6410 Send node, 9599 Send node,
6411 Node receiver, 9600 Node receiver,
6412 Node index, 9601 Node index,
6413 IncDecOperator operator, 9602 IncDecOperator operator,
6414 A arg) { 9603 A arg) {
6415 return handleDynamicIndexPostfixPrefix( 9604 return handleIndexCompounds(
6416 node, receiver, index, operator, arg, isPrefix: true); 9605 node, receiver, index,
9606 new IncDecCompound(CompoundKind.PREFIX, operator), arg);
6417 } 9607 }
6418 } 9608 }
6419 9609
9610
9611
6420 /// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by 9612 /// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by
6421 /// delegating calls to `handleSuperXPostfixPrefix` methods. 9613 /// delegating calls to `handleSuperXPostfixPrefix` methods.
6422 /// 9614 ///
6423 /// This mixin is useful for the cases where super prefix/postfix expression are 9615 /// This mixin is useful for the cases where super prefix/postfix expression are
6424 /// handled uniformly. 9616 /// handled uniformly.
6425 abstract class BaseImplementationOfSuperIncDecsMixin<R, A> 9617 abstract class BaseImplementationOfSuperIncDecsMixin<R, A>
6426 implements SemanticSendVisitor<R, A> { 9618 implements SemanticSendVisitor<R, A> {
6427 R handleSuperFieldFieldPostfixPrefix( 9619 R handleSuperFieldFieldPostfixPrefix(
6428 Send node, 9620 Send node,
6429 FieldElement readField, 9621 FieldElement readField,
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
6469 FunctionElement indexFunction, 9661 FunctionElement indexFunction,
6470 FunctionElement indexSetFunction, 9662 FunctionElement indexSetFunction,
6471 Node index, 9663 Node index,
6472 IncDecOperator operator, 9664 IncDecOperator operator,
6473 A arg, 9665 A arg,
6474 {bool isPrefix}); 9666 {bool isPrefix});
6475 9667
6476 R handleUnresolvedSuperGetterIndexPostfixPrefix( 9668 R handleUnresolvedSuperGetterIndexPostfixPrefix(
6477 Send node, 9669 Send node,
6478 Element element, 9670 Element element,
9671 MethodElement setter,
6479 Node index, 9672 Node index,
6480 IncDecOperator operator, 9673 IncDecOperator operator,
6481 A arg, 9674 A arg,
6482 {bool isPrefix}); 9675 {bool isPrefix});
6483 9676
6484 R handleUnresolvedSuperSetterIndexPostfixPrefix( 9677 R handleUnresolvedSuperSetterIndexPostfixPrefix(
6485 Send node, 9678 Send node,
6486 FunctionElement indexFunction, 9679 FunctionElement indexFunction,
6487 Element element, 9680 Element element,
6488 Node index, 9681 Node index,
6489 IncDecOperator operator, 9682 IncDecOperator operator,
6490 A arg, 9683 A arg,
6491 {bool isPrefix}); 9684 {bool isPrefix});
6492 9685
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
6493 @override 9731 @override
6494 R visitSuperFieldFieldPostfix( 9732 R visitSuperFieldFieldPostfix(
6495 Send node, 9733 Send node,
6496 FieldElement readField, 9734 FieldElement readField,
6497 FieldElement writtenField, 9735 FieldElement writtenField,
6498 IncDecOperator operator, 9736 IncDecOperator operator,
6499 A arg) { 9737 A arg) {
6500 return handleSuperFieldFieldPostfixPrefix( 9738 return handleSuperFieldFieldPostfixPrefix(
6501 node, readField, writtenField, operator, arg, isPrefix: false); 9739 node, readField, writtenField, operator, arg, isPrefix: false);
6502 } 9740 }
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after
6643 A arg) { 9881 A arg) {
6644 return handleSuperIndexPostfixPrefix( 9882 return handleSuperIndexPostfixPrefix(
6645 node, indexFunction, indexSetFunction, 9883 node, indexFunction, indexSetFunction,
6646 index, operator, arg, isPrefix: true); 9884 index, operator, arg, isPrefix: true);
6647 } 9885 }
6648 9886
6649 @override 9887 @override
6650 R visitUnresolvedSuperGetterIndexPostfix( 9888 R visitUnresolvedSuperGetterIndexPostfix(
6651 Send node, 9889 Send node,
6652 Element element, 9890 Element element,
9891 MethodElement setter,
6653 Node index, 9892 Node index,
6654 IncDecOperator operator, 9893 IncDecOperator operator,
6655 A arg) { 9894 A arg) {
6656 return handleUnresolvedSuperGetterIndexPostfixPrefix( 9895 return handleUnresolvedSuperGetterIndexPostfixPrefix(
6657 node, element, index, operator, arg, isPrefix: false); 9896 node, element, setter, index, operator, arg, isPrefix: false);
6658 } 9897 }
6659 9898
6660 @override 9899 @override
6661 R visitUnresolvedSuperGetterIndexPrefix( 9900 R visitUnresolvedSuperGetterIndexPrefix(
6662 Send node, 9901 Send node,
6663 Element element, 9902 Element element,
9903 MethodElement setter,
6664 Node index, 9904 Node index,
6665 IncDecOperator operator, 9905 IncDecOperator operator,
6666 A arg) { 9906 A arg) {
6667 return handleUnresolvedSuperGetterIndexPostfixPrefix( 9907 return handleUnresolvedSuperGetterIndexPostfixPrefix(
6668 node, element, index, operator, arg, isPrefix: true); 9908 node, element, setter, index, operator, arg, isPrefix: true);
6669 } 9909 }
6670 9910
6671 @override 9911 @override
6672 R visitUnresolvedSuperSetterIndexPostfix( 9912 R visitUnresolvedSuperSetterIndexPostfix(
6673 Send node, 9913 Send node,
6674 MethodElement indexFunction, 9914 MethodElement indexFunction,
6675 Element element, 9915 Element element,
6676 Node index, 9916 Node index,
6677 IncDecOperator operator, 9917 IncDecOperator operator,
6678 A arg) { 9918 A arg) {
6679 return handleUnresolvedSuperSetterIndexPostfixPrefix( 9919 return handleUnresolvedSuperSetterIndexPostfixPrefix(
6680 node, indexFunction, element, index, operator, arg, isPrefix: false); 9920 node, indexFunction, element, index, operator, arg, isPrefix: false);
6681 } 9921 }
6682 9922
6683 @override 9923 @override
6684 R visitUnresolvedSuperSetterIndexPrefix( 9924 R visitUnresolvedSuperSetterIndexPrefix(
6685 Send node, 9925 Send node,
6686 MethodElement indexFunction, 9926 MethodElement indexFunction,
6687 Element element, 9927 Element element,
6688 Node index, 9928 Node index,
6689 IncDecOperator operator, 9929 IncDecOperator operator,
6690 A arg) { 9930 A arg) {
6691 return handleUnresolvedSuperSetterIndexPostfixPrefix( 9931 return handleUnresolvedSuperSetterIndexPostfixPrefix(
6692 node, indexFunction, element, index, operator, arg, isPrefix: true); 9932 node, indexFunction, element, index, operator, arg, isPrefix: true);
6693 } 9933 }
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 }
6694 } 10060 }
6695 10061
6696 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by 10062 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by
6697 /// delegating calls to the `handleConstructorInvoke` method. 10063 /// delegating calls to the `handleConstructorInvoke` method.
6698 /// 10064 ///
6699 /// This mixin is useful for the cases where all constructor invocations are 10065 /// This mixin is useful for the cases where all constructor invocations are
6700 /// handled uniformly. 10066 /// handled uniformly.
6701 abstract class BaseImplementationOfNewMixin<R, A> 10067 abstract class BaseImplementationOfNewMixin<R, A>
6702 implements SemanticSendVisitor<R, A> { 10068 implements SemanticSendVisitor<R, A> {
6703 10069
6704 R handleConstructorInvoke( 10070 R handleConstructorInvoke(
6705 NewExpression node, 10071 NewExpression node,
6706 ConstructorElement constructor, 10072 ConstructorElement constructor,
6707 DartType type, 10073 DartType type,
6708 NodeList arguments, 10074 NodeList arguments,
6709 CallStructure callStructure, 10075 CallStructure callStructure,
6710 A arg); 10076 A arg);
6711 10077
6712 R visitGenerativeConstructorInvoke( 10078 R visitGenerativeConstructorInvoke(
6713 NewExpression node, 10079 NewExpression node,
6714 ConstructorElement constructor, 10080 ConstructorElement constructor,
6715 InterfaceType type, 10081 InterfaceType type,
6716 NodeList arguments, 10082 NodeList arguments,
6717 CallStructure callStructure, 10083 CallStructure callStructure,
6718 A arg) { 10084 A arg) {
6719 return handleConstructorInvoke( 10085 return handleConstructorInvoke(
6720 node, constructor, type, arguments, callStructure, arg); 10086 node, constructor, type, arguments, callStructure, arg);
6721 } 10087 }
6722 10088
10089 @override
6723 R visitRedirectingGenerativeConstructorInvoke( 10090 R visitRedirectingGenerativeConstructorInvoke(
6724 NewExpression node, 10091 NewExpression node,
6725 ConstructorElement constructor, 10092 ConstructorElement constructor,
6726 InterfaceType type, 10093 InterfaceType type,
6727 NodeList arguments, 10094 NodeList arguments,
6728 CallStructure callStructure, 10095 CallStructure callStructure,
6729 A arg) { 10096 A arg) {
6730 return handleConstructorInvoke( 10097 return handleConstructorInvoke(
6731 node, constructor, type, arguments, callStructure, arg); 10098 node, constructor, type, arguments, callStructure, arg);
6732 } 10099 }
6733 10100
10101 @override
6734 R visitFactoryConstructorInvoke( 10102 R visitFactoryConstructorInvoke(
6735 NewExpression node, 10103 NewExpression node,
6736 ConstructorElement constructor, 10104 ConstructorElement constructor,
6737 InterfaceType type, 10105 InterfaceType type,
6738 NodeList arguments, 10106 NodeList arguments,
6739 CallStructure callStructure, 10107 CallStructure callStructure,
6740 A arg) { 10108 A arg) {
6741 return handleConstructorInvoke( 10109 return handleConstructorInvoke(
6742 node, constructor, type, arguments, callStructure, arg); 10110 node, constructor, type, arguments, callStructure, arg);
6743 } 10111 }
6744 10112
10113 @override
6745 R visitRedirectingFactoryConstructorInvoke( 10114 R visitRedirectingFactoryConstructorInvoke(
6746 NewExpression node, 10115 NewExpression node,
6747 ConstructorElement constructor, 10116 ConstructorElement constructor,
6748 InterfaceType type, 10117 InterfaceType type,
6749 ConstructorElement effectiveTarget, 10118 ConstructorElement effectiveTarget,
6750 InterfaceType effectiveTargetType, 10119 InterfaceType effectiveTargetType,
6751 NodeList arguments, 10120 NodeList arguments,
6752 CallStructure callStructure, 10121 CallStructure callStructure,
6753 A arg) { 10122 A arg) {
6754 return handleConstructorInvoke( 10123 return handleConstructorInvoke(
6755 node, constructor, type, arguments, callStructure, arg); 10124 node, constructor, type, arguments, callStructure, arg);
6756 } 10125 }
6757 10126
10127 @override
6758 R visitUnresolvedConstructorInvoke( 10128 R visitUnresolvedConstructorInvoke(
6759 NewExpression node, 10129 NewExpression node,
6760 Element constructor, 10130 Element constructor,
6761 DartType type, 10131 DartType type,
6762 NodeList arguments, 10132 NodeList arguments,
6763 Selector selector, 10133 Selector selector,
6764 A arg) { 10134 A arg) {
6765 return handleConstructorInvoke( 10135 return handleConstructorInvoke(
6766 node, constructor, type, arguments, selector.callStructure, arg); 10136 node, constructor, type, arguments, selector.callStructure, arg);
6767 } 10137 }
6768 10138
10139 @override
6769 R visitUnresolvedClassConstructorInvoke( 10140 R visitUnresolvedClassConstructorInvoke(
6770 NewExpression node, 10141 NewExpression node,
6771 Element element, 10142 Element element,
6772 DartType type, 10143 DartType type,
6773 NodeList arguments, 10144 NodeList arguments,
6774 Selector selector, 10145 Selector selector,
6775 A arg) { 10146 A arg) {
6776 return handleConstructorInvoke( 10147 return handleConstructorInvoke(
6777 node, element, type, arguments, selector.callStructure, arg); 10148 node, element, type, arguments, selector.callStructure, arg);
6778 } 10149 }
6779 10150
10151 @override
6780 R visitAbstractClassConstructorInvoke( 10152 R visitAbstractClassConstructorInvoke(
6781 NewExpression node, 10153 NewExpression node,
6782 ConstructorElement constructor, 10154 ConstructorElement constructor,
6783 InterfaceType type, 10155 InterfaceType type,
6784 NodeList arguments, 10156 NodeList arguments,
6785 CallStructure callStructure, 10157 CallStructure callStructure,
6786 A arg) { 10158 A arg) {
6787 return handleConstructorInvoke( 10159 return handleConstructorInvoke(
6788 node, constructor, type, arguments, callStructure, arg); 10160 node, constructor, type, arguments, callStructure, arg);
6789 } 10161 }
10162
10163 @override
6790 R visitUnresolvedRedirectingFactoryConstructorInvoke( 10164 R visitUnresolvedRedirectingFactoryConstructorInvoke(
6791 NewExpression node, 10165 NewExpression node,
6792 ConstructorElement constructor, 10166 ConstructorElement constructor,
6793 InterfaceType type, 10167 InterfaceType type,
6794 NodeList arguments, 10168 NodeList arguments,
6795 CallStructure callStructure, 10169 CallStructure callStructure,
6796 A arg) { 10170 A arg) {
6797 return handleConstructorInvoke( 10171 return handleConstructorInvoke(
6798 node, constructor, type, arguments, callStructure, arg); 10172 node, constructor, type, arguments, callStructure, arg);
6799 } 10173 }
6800 } 10174 }
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