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

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: Use new BaseImplementation mixins in IrBuilderVisitor. 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
« pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart ('K') | « 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 InterfaceType type, 5455 InterfaceType 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 constant, like `Object += 42` or `--Object`.
7634 R handleConstantCompounds(
7635 SendSet node,
7636 ConstantExpression constant,
7637 CompoundRhs rhs,
7638 A arg);
7639
7640 /// Handle a compounds on a type variable type literal, like `T += 42` or
7641 /// `--T`.
7642 R handleTypeVariableTypeLiteralCompounds(
7643 SendSet node,
7644 TypeVariableElement typeVariable,
7645 CompoundRhs rhs,
7646 A arg);
7647
7648 /// Handle a dynamic compounds, like `o.foo += 42` or `--o.foo`. [receiver] is
7649 /// `null` for properties on `this`, like `--this.foo` or `--foo`.
7650 R handleDynamicCompounds(
7651 Send node,
7652 Node receiver,
7653 CompoundRhs rhs,
7654 Selector getterSelector,
7655 Selector setterSelector,
7656 A arg);
7657
7658 R visitDynamicPropertyCompound(
7659 Send node,
7660 Node receiver,
7661 AssignmentOperator operator,
7662 Node rhs,
7663 Selector getterSelector,
7664 Selector setterSelector,
7665 A arg) {
7666 return handleDynamicCompounds(
7667 node,
7668 receiver,
7669 new AssignmentCompound(operator, rhs),
7670 getterSelector,
7671 setterSelector,
7672 arg);
7673 }
7674
7675 @override
7676 R visitThisPropertyCompound(
7677 Send node,
7678 AssignmentOperator operator,
7679 Node rhs,
7680 Selector getterSelector,
7681 Selector setterSelector,
7682 A arg) {
7683 return handleDynamicCompounds(
7684 node,
7685 null,
7686 new AssignmentCompound(operator, rhs),
7687 getterSelector,
7688 setterSelector,
7689 arg);
7690 }
7691
7692 @override
7693 R visitParameterCompound(
7694 Send node,
7695 ParameterElement parameter,
7696 AssignmentOperator operator,
7697 Node rhs,
7698 A arg) {
7699 return handleLocalCompounds(
7700 node,
7701 parameter,
7702 new AssignmentCompound(operator, rhs),
7703 arg,
7704 isSetterValid: true);
7705 }
7706
7707 @override
7708 R visitFinalParameterCompound(
7709 Send node,
7710 ParameterElement parameter,
7711 AssignmentOperator operator,
7712 Node rhs,
7713 A arg) {
7714 return handleLocalCompounds(
7715 node,
7716 parameter,
7717 new AssignmentCompound(operator, rhs),
7718 arg,
7719 isSetterValid: false);
7720 }
7721
7722 @override
7723 R visitLocalVariableCompound(
7724 Send node,
7725 LocalVariableElement variable,
7726 AssignmentOperator operator,
7727 Node rhs,
7728 A arg) {
7729 return handleLocalCompounds(
7730 node,
7731 variable,
7732 new AssignmentCompound(operator, rhs),
7733 arg,
7734 isSetterValid: true);
7735 }
7736
7737 @override
7738 R visitFinalLocalVariableCompound(
7739 Send node,
7740 LocalVariableElement variable,
7741 AssignmentOperator operator,
7742 Node rhs,
7743 A arg) {
7744 return handleLocalCompounds(
7745 node,
7746 variable,
7747 new AssignmentCompound(operator, rhs),
7748 arg,
7749 isSetterValid: false);
7750 }
7751
7752 @override
7753 R visitLocalFunctionCompound(
7754 Send node,
7755 LocalFunctionElement function,
7756 AssignmentOperator operator,
7757 Node rhs,
7758 A arg) {
7759 return handleLocalCompounds(
7760 node,
7761 function,
7762 new AssignmentCompound(operator, rhs),
7763 arg,
7764 isSetterValid: false);
7765 }
7766
7767 @override
7768 R visitStaticFieldCompound(
7769 Send node,
7770 FieldElement field,
7771 AssignmentOperator operator,
7772 Node rhs,
7773 A arg) {
7774 return handleStaticCompounds(
7775 node,
7776 field, CompoundGetter.FIELD,
7777 field, CompoundSetter.FIELD,
7778 new AssignmentCompound(operator, rhs),
7779 arg);
7780 }
7781
7782 @override
7783 R visitFinalStaticFieldCompound(
7784 Send node,
7785 FieldElement field,
7786 AssignmentOperator operator,
7787 Node rhs,
7788 A arg) {
7789 return handleStaticCompounds(
7790 node,
7791 field, CompoundGetter.FIELD,
7792 null, CompoundSetter.INVALID,
7793 new AssignmentCompound(operator, rhs),
7794 arg);
7795 }
7796
7797 @override
7798 R visitStaticGetterSetterCompound(
7799 Send node,
7800 FunctionElement getter,
7801 FunctionElement setter,
7802 AssignmentOperator operator,
7803 Node rhs,
7804 A arg) {
7805 return handleStaticCompounds(
7806 node,
7807 getter, CompoundGetter.GETTER,
7808 setter, CompoundSetter.SETTER,
7809 new AssignmentCompound(operator, rhs),
7810 arg);
7811 }
7812
7813 @override
7814 R visitStaticMethodSetterCompound(
7815 Send node,
7816 FunctionElement method,
7817 FunctionElement setter,
7818 AssignmentOperator operator,
7819 Node rhs,
7820 A arg) {
7821 return handleStaticCompounds(
7822 node,
7823 method, CompoundGetter.METHOD,
7824 setter, CompoundSetter.SETTER,
7825 new AssignmentCompound(operator, rhs),
7826 arg);
7827 }
7828
7829 @override
7830 R visitTopLevelFieldCompound(
7831 Send node,
7832 FieldElement field,
7833 AssignmentOperator operator,
7834 Node rhs,
7835 A arg) {
7836 return handleStaticCompounds(
7837 node,
7838 field, CompoundGetter.FIELD,
7839 field, CompoundSetter.FIELD,
7840 new AssignmentCompound(operator, rhs),
7841 arg);
7842 }
7843
7844 @override
7845 R visitFinalTopLevelFieldCompound(
7846 Send node,
7847 FieldElement field,
7848 AssignmentOperator operator,
7849 Node rhs,
7850 A arg) {
7851 return handleStaticCompounds(
7852 node,
7853 field, CompoundGetter.FIELD,
7854 null, CompoundSetter.INVALID,
7855 new AssignmentCompound(operator, rhs),
7856 arg);
7857 }
7858
7859 @override
7860 R visitTopLevelGetterSetterCompound(
7861 Send node,
7862 FunctionElement getter,
7863 FunctionElement setter,
7864 AssignmentOperator operator,
7865 Node rhs,
7866 A arg) {
7867 return handleStaticCompounds(
7868 node,
7869 getter, CompoundGetter.GETTER,
7870 setter, CompoundSetter.SETTER,
7871 new AssignmentCompound(operator, rhs),
7872 arg);
7873 }
7874
7875 @override
7876 R visitTopLevelMethodSetterCompound(
7877 Send node,
7878 FunctionElement method,
7879 FunctionElement setter,
7880 AssignmentOperator operator,
7881 Node rhs,
7882 A arg) {
7883 return handleStaticCompounds(
7884 node,
7885 method, CompoundGetter.METHOD,
7886 setter, CompoundSetter.SETTER,
7887 new AssignmentCompound(operator, rhs),
7888 arg);
7889 }
7890
7891 @override
7892 R visitSuperFieldCompound(
7893 Send node,
7894 FieldElement field,
7895 AssignmentOperator operator,
7896 Node rhs,
7897 A arg) {
7898 return handleSuperCompounds(
7899 node,
7900 field, CompoundGetter.FIELD,
7901 field, CompoundSetter.FIELD,
7902 new AssignmentCompound(operator, rhs),
7903 arg);
7904 }
7905
7906 @override
7907 R visitFinalSuperFieldCompound(
7908 Send node,
7909 FieldElement field,
7910 AssignmentOperator operator,
7911 Node rhs,
7912 A arg) {
7913 return handleSuperCompounds(
7914 node,
7915 field, CompoundGetter.FIELD,
7916 field, CompoundSetter.INVALID,
7917 new AssignmentCompound(operator, rhs),
7918 arg);
7919 }
7920
7921 @override
7922 R visitSuperGetterSetterCompound(
7923 Send node,
7924 FunctionElement getter,
7925 FunctionElement setter,
7926 AssignmentOperator operator,
7927 Node rhs,
7928 A arg) {
7929 return handleSuperCompounds(
7930 node,
7931 getter, CompoundGetter.GETTER,
7932 setter, CompoundSetter.SETTER,
7933 new AssignmentCompound(operator, rhs),
7934 arg);
7935 }
7936
7937 @override
7938 R visitSuperMethodSetterCompound(
7939 Send node,
7940 FunctionElement method,
7941 FunctionElement setter,
7942 AssignmentOperator operator,
7943 Node rhs,
7944 A arg) {
7945 return handleSuperCompounds(
7946 node,
7947 method, CompoundGetter.METHOD,
7948 setter, CompoundSetter.SETTER,
7949 new AssignmentCompound(operator, rhs),
7950 arg);
7951 }
7952
7953 @override
7954 R visitSuperFieldSetterCompound(
7955 Send node,
7956 FieldElement field,
7957 FunctionElement setter,
7958 AssignmentOperator operator,
7959 Node rhs,
7960 A arg) {
7961 return handleSuperCompounds(
7962 node,
7963 field, CompoundGetter.FIELD,
7964 setter, CompoundSetter.SETTER,
7965 new AssignmentCompound(operator, rhs),
7966 arg);
7967 }
7968
7969 @override
7970 R visitSuperGetterFieldCompound(
7971 Send node,
7972 FunctionElement getter,
7973 FieldElement field,
7974 AssignmentOperator operator,
7975 Node rhs,
7976 A arg) {
7977 return handleSuperCompounds(
7978 node,
7979 getter, CompoundGetter.GETTER,
7980 field, CompoundSetter.FIELD,
7981 new AssignmentCompound(operator, rhs),
7982 arg);
7983 }
7984
7985 @override
7986 R visitClassTypeLiteralCompound(
7987 Send node,
7988 ConstantExpression constant,
7989 AssignmentOperator operator,
7990 Node rhs,
7991 A arg) {
7992 return handleConstantCompounds(
7993 node,
7994 constant,
7995 new AssignmentCompound(operator, rhs),
7996 arg);
7997 }
7998
7999 @override
8000 R visitTypedefTypeLiteralCompound(
8001 Send node,
8002 ConstantExpression constant,
8003 AssignmentOperator operator,
8004 Node rhs,
8005 A arg) {
8006 return handleConstantCompounds(
8007 node,
8008 constant,
8009 new AssignmentCompound(operator, rhs),
8010 arg);
8011 }
8012
8013 @override
8014 R visitTypeVariableTypeLiteralCompound(
8015 Send node,
8016 TypeVariableElement element,
8017 AssignmentOperator operator,
8018 Node rhs,
8019 A arg) {
8020 return handleTypeVariableTypeLiteralCompounds(
8021 node,
8022 element,
8023 new AssignmentCompound(operator, rhs),
8024 arg);
8025 }
8026
8027 @override
8028 R visitDynamicTypeLiteralCompound(
8029 Send node,
8030 ConstantExpression constant,
8031 AssignmentOperator operator,
8032 Node rhs,
8033 A arg) {
8034 return handleConstantCompounds(
8035 node,
8036 constant,
8037 new AssignmentCompound(operator, rhs),
8038 arg);
8039 }
8040
8041
8042 R visitDynamicPropertyPrefix(
8043 Send node,
8044 Node receiver,
8045 IncDecOperator operator,
8046 Selector getterSelector,
8047 Selector setterSelector,
8048 A arg) {
8049 return handleDynamicCompounds(
8050 node,
8051 receiver,
8052 new IncDecCompound(CompoundKind.PREFIX, operator),
8053 getterSelector,
8054 setterSelector,
8055 arg);
8056 }
8057
8058 @override
8059 R visitParameterPrefix(
8060 Send node,
8061 ParameterElement parameter,
8062 IncDecOperator operator,
8063 A arg) {
8064 return handleLocalCompounds(
8065 node,
8066 parameter,
8067 new IncDecCompound(CompoundKind.PREFIX, operator),
8068 arg,
8069 isSetterValid: true);
8070 }
8071
8072 @override
8073 R visitLocalVariablePrefix(
8074 Send node,
8075 LocalVariableElement variable,
8076 IncDecOperator operator,
8077 A arg) {
8078 return handleLocalCompounds(
8079 node,
8080 variable,
8081 new IncDecCompound(CompoundKind.PREFIX, operator),
8082 arg,
8083 isSetterValid: true);
8084 }
8085
8086 @override
8087 R visitLocalFunctionPrefix(
8088 Send node,
8089 LocalFunctionElement function,
8090 IncDecOperator operator,
8091 A arg) {
8092 return handleLocalCompounds(
8093 node,
8094 function,
8095 new IncDecCompound(CompoundKind.PREFIX, operator),
8096 arg,
8097 isSetterValid: false);
8098 }
8099
8100
8101 R visitThisPropertyPrefix(
8102 Send node,
8103 IncDecOperator operator,
8104 Selector getterSelector,
8105 Selector setterSelector,
8106 A arg) {
8107 return handleDynamicCompounds(
8108 node,
8109 null,
8110 new IncDecCompound(CompoundKind.PREFIX, operator),
8111 getterSelector,
8112 setterSelector,
8113 arg);
8114 }
8115
8116 @override
8117 R visitStaticFieldPrefix(
8118 Send node,
8119 FieldElement field,
8120 IncDecOperator operator,
8121 A arg) {
8122 return handleStaticCompounds(
8123 node,
8124 field, CompoundGetter.FIELD,
8125 field, CompoundSetter.FIELD,
8126 new IncDecCompound(CompoundKind.PREFIX, operator),
8127 arg);
8128 }
8129
8130 @override
8131 R visitStaticGetterSetterPrefix(
8132 Send node,
8133 FunctionElement getter,
8134 FunctionElement setter,
8135 IncDecOperator operator,
8136 A arg) {
8137 return handleStaticCompounds(
8138 node,
8139 getter, CompoundGetter.GETTER,
8140 setter, CompoundSetter.SETTER,
8141 new IncDecCompound(CompoundKind.PREFIX, operator),
8142 arg);
8143 }
8144
8145
8146 R visitStaticMethodSetterPrefix(
8147 Send node,
8148 FunctionElement getter,
8149 FunctionElement setter,
8150 IncDecOperator operator,
8151 A arg) {
8152 return handleStaticCompounds(
8153 node,
8154 getter, CompoundGetter.METHOD,
8155 setter, CompoundSetter.SETTER,
8156 new IncDecCompound(CompoundKind.PREFIX, operator),
8157 arg);
8158 }
8159
8160 @override
8161 R visitTopLevelFieldPrefix(
8162 Send node,
8163 FieldElement field,
8164 IncDecOperator operator,
8165 A arg) {
8166 return handleStaticCompounds(
8167 node,
8168 field, CompoundGetter.FIELD,
8169 field, CompoundSetter.FIELD,
8170 new IncDecCompound(CompoundKind.PREFIX, operator),
8171 arg);
8172 }
8173
8174 @override
8175 R visitTopLevelGetterSetterPrefix(
8176 Send node,
8177 FunctionElement getter,
8178 FunctionElement setter,
8179 IncDecOperator operator,
8180 A arg) {
8181 return handleStaticCompounds(
8182 node,
8183 getter, CompoundGetter.GETTER,
8184 setter, CompoundSetter.SETTER,
8185 new IncDecCompound(CompoundKind.PREFIX, operator),
8186 arg);
8187 }
8188
8189 @override
8190 R visitTopLevelMethodSetterPrefix(
8191 Send node,
8192 FunctionElement method,
8193 FunctionElement setter,
8194 IncDecOperator operator,
8195 A arg) {
8196 return handleStaticCompounds(
8197 node,
8198 method, CompoundGetter.METHOD,
8199 setter, CompoundSetter.SETTER,
8200 new IncDecCompound(CompoundKind.PREFIX, operator),
8201 arg);
8202 }
8203
8204 @override
8205 R visitSuperFieldPrefix(
8206 Send node,
8207 FieldElement field,
8208 IncDecOperator operator,
8209 A arg) {
8210 return handleSuperCompounds(
8211 node,
8212 field, CompoundGetter.FIELD,
8213 field, CompoundSetter.FIELD,
8214 new IncDecCompound(CompoundKind.PREFIX, operator),
8215 arg);
8216 }
8217
8218 @override
8219 R visitSuperFieldFieldPrefix(
8220 Send node,
8221 FieldElement readField,
8222 FieldElement writtenField,
8223 IncDecOperator operator,
8224 A arg) {
8225 return handleSuperCompounds(
8226 node,
8227 readField, CompoundGetter.FIELD,
8228 writtenField, CompoundSetter.FIELD,
8229 new IncDecCompound(CompoundKind.PREFIX, operator),
8230 arg);
8231 }
8232
8233 @override
8234 R visitSuperFieldSetterPrefix(
8235 Send node,
8236 FieldElement field,
8237 FunctionElement setter,
8238 IncDecOperator operator,
8239 A arg) {
8240 return handleSuperCompounds(
8241 node,
8242 field, CompoundGetter.FIELD,
8243 setter, CompoundSetter.SETTER,
8244 new IncDecCompound(CompoundKind.PREFIX, operator),
8245 arg);
8246 }
8247
8248
8249 R visitSuperGetterSetterPrefix(
8250 Send node,
8251 FunctionElement getter,
8252 FunctionElement setter,
8253 IncDecOperator operator,
8254 A arg) {
8255 return handleSuperCompounds(
8256 node,
8257 getter, CompoundGetter.GETTER,
8258 setter, CompoundSetter.SETTER,
8259 new IncDecCompound(CompoundKind.PREFIX, operator),
8260 arg);
8261 }
8262
8263 @override
8264 R visitSuperGetterFieldPrefix(
8265 Send node,
8266 FunctionElement getter,
8267 FieldElement field,
8268 IncDecOperator operator,
8269 A arg) {
8270 return handleSuperCompounds(
8271 node,
8272 getter, CompoundGetter.GETTER,
8273 field, CompoundSetter.FIELD,
8274 new IncDecCompound(CompoundKind.PREFIX, operator),
8275 arg);
8276 }
8277
8278 @override
8279 R visitSuperMethodSetterPrefix(
8280 Send node,
8281 FunctionElement method,
8282 FunctionElement setter,
8283 IncDecOperator operator,
8284 A arg) {
8285 return handleSuperCompounds(
8286 node,
8287 method, CompoundGetter.METHOD,
8288 setter, CompoundSetter.SETTER,
8289 new IncDecCompound(CompoundKind.PREFIX, operator),
8290 arg);
8291 }
8292
8293 @override
8294 R visitClassTypeLiteralPrefix(
8295 Send node,
8296 ConstantExpression constant,
8297 IncDecOperator operator,
8298 A arg) {
8299 return handleConstantCompounds(
8300 node,
8301 constant,
8302 new IncDecCompound(CompoundKind.PREFIX, operator),
8303 arg);
8304 }
8305
8306 @override
8307 R visitTypedefTypeLiteralPrefix(
8308 Send node,
8309 ConstantExpression constant,
8310 IncDecOperator operator,
8311 A arg) {
8312 return handleConstantCompounds(
8313 node,
8314 constant,
8315 new IncDecCompound(CompoundKind.PREFIX, operator),
8316 arg);
8317 }
8318
8319 @override
8320 R visitTypeVariableTypeLiteralPrefix(
8321 Send node,
8322 TypeVariableElement element,
8323 IncDecOperator operator,
8324 A arg) {
8325 return handleTypeVariableTypeLiteralCompounds(
8326 node,
8327 element,
8328 new IncDecCompound(CompoundKind.PREFIX, operator),
8329 arg);
8330 }
8331
8332 @override
8333 R visitDynamicTypeLiteralPrefix(
8334 Send node,
8335 ConstantExpression constant,
8336 IncDecOperator operator,
8337 A arg) {
8338 return handleConstantCompounds(
8339 node,
8340 constant,
8341 new IncDecCompound(CompoundKind.PREFIX, operator),
8342 arg);
8343 }
8344
8345 @override
8346 R visitDynamicPropertyPostfix(
8347 Send node,
8348 Node receiver,
8349 IncDecOperator operator,
8350 Selector getterSelector,
8351 Selector setterSelector,
8352 A arg) {
8353 return handleDynamicCompounds(
8354 node,
8355 receiver,
8356 new IncDecCompound(CompoundKind.POSTFIX, operator),
8357 getterSelector,
8358 setterSelector,
8359 arg);
8360 }
8361
8362 @override
8363 R visitParameterPostfix(
8364 Send node,
8365 ParameterElement parameter,
8366 IncDecOperator operator,
8367 A arg) {
8368 return handleLocalCompounds(
8369 node,
8370 parameter,
8371 new IncDecCompound(CompoundKind.POSTFIX, operator),
8372 arg,
8373 isSetterValid: true);
8374 }
8375
8376 @override
8377 R visitLocalVariablePostfix(
8378 Send node,
8379 LocalVariableElement variable,
8380 IncDecOperator operator,
8381 A arg) {
8382 return handleLocalCompounds(
8383 node,
8384 variable,
8385 new IncDecCompound(CompoundKind.POSTFIX, operator),
8386 arg,
8387 isSetterValid: true);
8388 }
8389
8390 @override
8391 R visitLocalFunctionPostfix(
8392 Send node,
8393 LocalFunctionElement function,
8394 IncDecOperator operator,
8395 A arg) {
8396 return handleLocalCompounds(
8397 node,
8398 function,
8399 new IncDecCompound(CompoundKind.POSTFIX, operator),
8400 arg,
8401 isSetterValid: false);
8402 }
8403
8404
8405 R visitThisPropertyPostfix(
8406 Send node,
8407 IncDecOperator operator,
8408 Selector getterSelector,
8409 Selector setterSelector,
8410 A arg) {
8411 return handleDynamicCompounds(
8412 node,
8413 null,
8414 new IncDecCompound(CompoundKind.POSTFIX, operator),
8415 getterSelector,
8416 setterSelector,
8417 arg);
8418 }
8419
8420 @override
8421 R visitStaticFieldPostfix(
8422 Send node,
8423 FieldElement field,
8424 IncDecOperator operator,
8425 A arg) {
8426 return handleStaticCompounds(
8427 node,
8428 field, CompoundGetter.FIELD,
8429 field, CompoundSetter.FIELD,
8430 new IncDecCompound(CompoundKind.POSTFIX, operator),
8431 arg);
8432 }
8433
8434 @override
8435 R visitStaticGetterSetterPostfix(
8436 Send node,
8437 FunctionElement getter,
8438 FunctionElement setter,
8439 IncDecOperator operator,
8440 A arg) {
8441 return handleStaticCompounds(
8442 node,
8443 getter, CompoundGetter.GETTER,
8444 setter, CompoundSetter.SETTER,
8445 new IncDecCompound(CompoundKind.POSTFIX, operator),
8446 arg);
8447 }
8448
8449
8450 R visitStaticMethodSetterPostfix(
8451 Send node,
8452 FunctionElement getter,
8453 FunctionElement setter,
8454 IncDecOperator operator,
8455 A arg) {
8456 return handleStaticCompounds(
8457 node,
8458 getter, CompoundGetter.METHOD,
8459 setter, CompoundSetter.SETTER,
8460 new IncDecCompound(CompoundKind.POSTFIX, operator),
8461 arg);
8462 }
8463
8464 @override
8465 R visitTopLevelFieldPostfix(
8466 Send node,
8467 FieldElement field,
8468 IncDecOperator operator,
8469 A arg) {
8470 return handleStaticCompounds(
8471 node,
8472 field, CompoundGetter.FIELD,
8473 field, CompoundSetter.FIELD,
8474 new IncDecCompound(CompoundKind.POSTFIX, operator),
8475 arg);
8476 }
8477
8478 @override
8479 R visitTopLevelGetterSetterPostfix(
8480 Send node,
8481 FunctionElement getter,
8482 FunctionElement setter,
8483 IncDecOperator operator,
8484 A arg) {
8485 return handleStaticCompounds(
8486 node,
8487 getter, CompoundGetter.GETTER,
8488 setter, CompoundSetter.SETTER,
8489 new IncDecCompound(CompoundKind.POSTFIX, operator),
8490 arg);
8491 }
8492
8493 @override
8494 R visitTopLevelMethodSetterPostfix(
8495 Send node,
8496 FunctionElement method,
8497 FunctionElement setter,
8498 IncDecOperator operator,
8499 A arg) {
8500 return handleStaticCompounds(
8501 node,
8502 method, CompoundGetter.METHOD,
8503 setter, CompoundSetter.SETTER,
8504 new IncDecCompound(CompoundKind.POSTFIX, operator),
8505 arg);
8506 }
8507
8508 @override
8509 R visitSuperFieldPostfix(
8510 Send node,
8511 FieldElement field,
8512 IncDecOperator operator,
8513 A arg) {
8514 return handleSuperCompounds(
8515 node,
8516 field, CompoundGetter.FIELD,
8517 field, CompoundSetter.FIELD,
8518 new IncDecCompound(CompoundKind.POSTFIX, operator),
8519 arg);
8520 }
8521
8522 @override
8523 R visitSuperFieldFieldPostfix(
8524 Send node,
8525 FieldElement readField,
8526 FieldElement writtenField,
8527 IncDecOperator operator,
8528 A arg) {
8529 return handleSuperCompounds(
8530 node,
8531 readField, CompoundGetter.FIELD,
8532 writtenField, CompoundSetter.FIELD,
8533 new IncDecCompound(CompoundKind.POSTFIX, operator),
8534 arg);
8535 }
8536
8537 @override
8538 R visitSuperFieldSetterPostfix(
8539 Send node,
8540 FieldElement field,
8541 FunctionElement setter,
8542 IncDecOperator operator,
8543 A arg) {
8544 return handleSuperCompounds(
8545 node,
8546 field, CompoundGetter.FIELD,
8547 setter, CompoundSetter.SETTER,
8548 new IncDecCompound(CompoundKind.POSTFIX, operator),
8549 arg);
8550 }
8551
8552
8553 R visitSuperGetterSetterPostfix(
8554 Send node,
8555 FunctionElement getter,
8556 FunctionElement setter,
8557 IncDecOperator operator,
8558 A arg) {
8559 return handleSuperCompounds(
8560 node,
8561 getter, CompoundGetter.GETTER,
8562 setter, CompoundSetter.SETTER,
8563 new IncDecCompound(CompoundKind.POSTFIX, operator),
8564 arg);
8565 }
8566
8567 @override
8568 R visitSuperGetterFieldPostfix(
8569 Send node,
8570 FunctionElement getter,
8571 FieldElement field,
8572 IncDecOperator operator,
8573 A arg) {
8574 return handleSuperCompounds(
8575 node,
8576 getter, CompoundGetter.GETTER,
8577 field, CompoundSetter.FIELD,
8578 new IncDecCompound(CompoundKind.POSTFIX, operator),
8579 arg);
8580 }
8581
8582 @override
8583 R visitSuperMethodSetterPostfix(
8584 Send node,
8585 FunctionElement method,
8586 FunctionElement setter,
8587 IncDecOperator operator,
8588 A arg) {
8589 return handleSuperCompounds(
8590 node,
8591 method, CompoundGetter.METHOD,
8592 setter, CompoundSetter.SETTER,
8593 new IncDecCompound(CompoundKind.POSTFIX, operator),
8594 arg);
8595 }
8596
8597 @override
8598 R visitClassTypeLiteralPostfix(
8599 Send node,
8600 ConstantExpression constant,
8601 IncDecOperator operator,
8602 A arg) {
8603 return handleConstantCompounds(
8604 node,
8605 constant,
8606 new IncDecCompound(CompoundKind.POSTFIX, operator),
8607 arg);
8608 }
8609
8610 @override
8611 R visitTypedefTypeLiteralPostfix(
8612 Send node,
8613 ConstantExpression constant,
8614 IncDecOperator operator,
8615 A arg) {
8616 return handleConstantCompounds(
8617 node,
8618 constant,
8619 new IncDecCompound(CompoundKind.POSTFIX, operator),
8620 arg);
8621 }
8622
8623 @override
8624 R visitTypeVariableTypeLiteralPostfix(
8625 Send node,
8626 TypeVariableElement element,
8627 IncDecOperator operator,
8628 A arg) {
8629 return handleTypeVariableTypeLiteralCompounds(
8630 node,
8631 element,
8632 new IncDecCompound(CompoundKind.POSTFIX, operator),
8633 arg);
8634 }
8635
8636 @override
8637 R visitDynamicTypeLiteralPostfix(
8638 Send node,
8639 ConstantExpression constant,
8640 IncDecOperator operator,
8641 A arg) {
8642 return handleConstantCompounds(
8643 node,
8644 constant,
8645 new IncDecCompound(CompoundKind.POSTFIX, operator),
8646 arg);
8647 }
8648
8649 @override
8650 R visitUnresolvedStaticGetterPostfix(
8651 Send node,
8652 Element element,
8653 MethodElement setter,
8654 IncDecOperator operator,
8655 A arg) {
8656 return handleStaticCompounds(
8657 node,
8658 element,
8659 CompoundGetter.UNRESOLVED,
8660 setter,
8661 CompoundSetter.SETTER,
8662 new IncDecCompound(CompoundKind.POSTFIX, operator),
8663 arg);
8664 }
8665
8666 @override
8667 R visitUnresolvedTopLevelGetterPostfix(
8668 Send node,
8669 Element element,
8670 MethodElement setter,
8671 IncDecOperator operator,
8672 A arg) {
8673 return handleStaticCompounds(
8674 node,
8675 element,
8676 CompoundGetter.UNRESOLVED,
8677 setter,
8678 CompoundSetter.SETTER,
8679 new IncDecCompound(CompoundKind.POSTFIX, operator),
8680 arg);
8681 }
8682
8683 @override
8684 R visitUnresolvedStaticSetterPostfix(
8685 Send node,
8686 MethodElement getter,
8687 Element element,
8688 IncDecOperator operator,
8689 A arg) {
8690 return handleStaticCompounds(
8691 node,
8692 getter,
8693 CompoundGetter.GETTER,
8694 element,
8695 CompoundSetter.INVALID,
8696 new IncDecCompound(CompoundKind.POSTFIX, operator),
8697 arg);
8698 }
8699
8700 @override
8701 R visitUnresolvedTopLevelSetterPostfix(
8702 Send node,
8703 MethodElement getter,
8704 Element element,
8705 IncDecOperator operator,
8706 A arg) {
8707 return handleStaticCompounds(
8708 node,
8709 getter,
8710 CompoundGetter.GETTER,
8711 element,
8712 CompoundSetter.INVALID,
8713 new IncDecCompound(CompoundKind.POSTFIX, operator),
8714 arg);
8715 }
8716
8717 @override
8718 R visitStaticMethodPostfix(
8719 Send node,
8720 MethodElement method,
8721 IncDecOperator operator,
8722 A arg) {
8723 return handleStaticCompounds(
8724 node,
8725 method,
8726 CompoundGetter.METHOD,
8727 method,
8728 CompoundSetter.INVALID,
8729 new IncDecCompound(CompoundKind.POSTFIX, operator),
8730 arg);
8731 }
8732
8733 @override
8734 R visitTopLevelMethodPostfix(
8735 Send node,
8736 MethodElement method,
8737 IncDecOperator operator,
8738 A arg) {
8739 return handleStaticCompounds(
8740 node,
8741 method,
8742 CompoundGetter.METHOD,
8743 method,
8744 CompoundSetter.INVALID,
8745 new IncDecCompound(CompoundKind.POSTFIX, operator),
8746 arg);
8747 }
8748
8749 @override
8750 R visitUnresolvedPostfix(
8751 Send node,
8752 Element element,
8753 IncDecOperator operator,
8754 A arg) {
8755 return handleStaticCompounds(
8756 node,
8757 element,
8758 CompoundGetter.UNRESOLVED,
8759 element,
8760 CompoundSetter.INVALID,
8761 new IncDecCompound(CompoundKind.POSTFIX, operator),
8762 arg);
8763 }
8764
8765 @override
8766 R visitUnresolvedStaticGetterPrefix(
8767 Send node,
8768 Element element,
8769 MethodElement setter,
8770 IncDecOperator operator,
8771 A arg) {
8772 return handleStaticCompounds(
8773 node,
8774 element,
8775 CompoundGetter.UNRESOLVED,
8776 setter,
8777 CompoundSetter.SETTER,
8778 new IncDecCompound(CompoundKind.PREFIX, operator),
8779 arg);
8780 }
8781
8782 @override
8783 R visitUnresolvedTopLevelGetterPrefix(
8784 Send node,
8785 Element element,
8786 MethodElement setter,
8787 IncDecOperator operator,
8788 A arg) {
8789 return handleStaticCompounds(
8790 node,
8791 element,
8792 CompoundGetter.UNRESOLVED,
8793 setter,
8794 CompoundSetter.SETTER,
8795 new IncDecCompound(CompoundKind.PREFIX, operator),
8796 arg);
8797 }
8798
8799 @override
8800 R visitUnresolvedStaticSetterPrefix(
8801 Send node,
8802 MethodElement getter,
8803 Element element,
8804 IncDecOperator operator,
8805 A arg) {
8806 return handleStaticCompounds(
8807 node,
8808 getter,
8809 CompoundGetter.GETTER,
8810 element,
8811 CompoundSetter.INVALID,
8812 new IncDecCompound(CompoundKind.PREFIX, operator),
8813 arg);
8814 }
8815
8816 @override
8817 R visitUnresolvedTopLevelSetterPrefix(
8818 Send node,
8819 MethodElement getter,
8820 Element element,
8821 IncDecOperator operator,
8822 A arg) {
8823 return handleStaticCompounds(
8824 node,
8825 getter,
8826 CompoundGetter.GETTER,
8827 element,
8828 CompoundSetter.INVALID,
8829 new IncDecCompound(CompoundKind.PREFIX, operator),
8830 arg);
8831 }
8832
8833 @override
8834 R visitStaticMethodPrefix(
8835 Send node,
8836 MethodElement method,
8837 IncDecOperator operator,
8838 A arg) {
8839 return handleStaticCompounds(
8840 node,
8841 method,
8842 CompoundGetter.METHOD,
8843 method,
8844 CompoundSetter.INVALID,
8845 new IncDecCompound(CompoundKind.PREFIX, operator),
8846 arg);
8847 }
8848
8849 @override
8850 R visitTopLevelMethodPrefix(
8851 Send node,
8852 MethodElement method,
8853 IncDecOperator operator,
8854 A arg) {
8855 return handleStaticCompounds(
8856 node,
8857 method,
8858 CompoundGetter.METHOD,
8859 method,
8860 CompoundSetter.INVALID,
8861 new IncDecCompound(CompoundKind.PREFIX, operator),
8862 arg);
8863 }
8864
8865 @override
8866 R visitUnresolvedPrefix(
8867 Send node,
8868 Element element,
8869 IncDecOperator operator,
8870 A arg) {
8871 return handleStaticCompounds(
8872 node,
8873 element,
8874 CompoundGetter.UNRESOLVED,
8875 element,
8876 CompoundSetter.INVALID,
8877 new IncDecCompound(CompoundKind.PREFIX, operator),
8878 arg);
8879 }
8880
8881 @override
8882 R visitUnresolvedStaticGetterCompound(
8883 Send node,
8884 Element element,
8885 MethodElement setter,
8886 AssignmentOperator operator,
8887 Node rhs,
8888 A arg) {
8889 return handleStaticCompounds(
8890 node,
8891 element,
8892 CompoundGetter.UNRESOLVED,
8893 setter,
8894 CompoundSetter.SETTER,
8895 new AssignmentCompound(operator, rhs),
8896 arg);
8897 }
8898
8899 @override
8900 R visitUnresolvedTopLevelGetterCompound(
8901 Send node,
8902 Element element,
8903 MethodElement setter,
8904 AssignmentOperator operator,
8905 Node rhs,
8906 A arg) {
8907 return handleStaticCompounds(
8908 node,
8909 element,
8910 CompoundGetter.UNRESOLVED,
8911 setter,
8912 CompoundSetter.SETTER,
8913 new AssignmentCompound(operator, rhs),
8914 arg);
8915 }
8916
8917 @override
8918 R visitUnresolvedStaticSetterCompound(
8919 Send node,
8920 MethodElement getter,
8921 Element element,
8922 AssignmentOperator operator,
8923 Node rhs,
8924 A arg) {
8925 return handleStaticCompounds(
8926 node,
8927 getter,
8928 CompoundGetter.GETTER,
8929 element,
8930 CompoundSetter.INVALID,
8931 new AssignmentCompound(operator, rhs),
8932 arg);
8933 }
8934
8935 @override
8936 R visitUnresolvedTopLevelSetterCompound(
8937 Send node,
8938 MethodElement getter,
8939 Element element,
8940 AssignmentOperator operator,
8941 Node rhs,
8942 A arg) {
8943 return handleStaticCompounds(
8944 node,
8945 getter,
8946 CompoundGetter.GETTER,
8947 element,
8948 CompoundSetter.INVALID,
8949 new AssignmentCompound(operator, rhs),
8950 arg);
8951 }
8952
8953 @override
8954 R visitStaticMethodCompound(
8955 Send node,
8956 MethodElement method,
8957 AssignmentOperator operator,
8958 Node rhs,
8959 A arg) {
8960 return handleStaticCompounds(
8961 node,
8962 method,
8963 CompoundGetter.METHOD,
8964 method,
8965 CompoundSetter.INVALID,
8966 new AssignmentCompound(operator, rhs),
8967 arg);
8968 }
8969
8970 @override
8971 R visitTopLevelMethodCompound(
8972 Send node,
8973 MethodElement method,
8974 AssignmentOperator operator,
8975 Node rhs,
8976 A arg) {
8977 return handleStaticCompounds(
8978 node,
8979 method,
8980 CompoundGetter.METHOD,
8981 method,
8982 CompoundSetter.INVALID,
8983 new AssignmentCompound(operator, rhs),
8984 arg);
8985 }
8986
8987 @override
8988 R visitUnresolvedCompound(
8989 Send node,
8990 Element element,
8991 AssignmentOperator operator,
8992 Node rhs,
8993 A arg) {
8994 return handleStaticCompounds(
8995 node,
8996 element,
8997 CompoundGetter.UNRESOLVED,
8998 element,
8999 CompoundSetter.INVALID,
9000 new AssignmentCompound(operator, rhs),
9001 arg);
9002 }
9003
9004 @override
9005 R visitFinalLocalVariablePostfix(
9006 Send node,
9007 LocalVariableElement variable,
9008 IncDecOperator operator,
9009 A arg) {
9010 return handleLocalCompounds(
9011 node,
9012 variable,
9013 new IncDecCompound(CompoundKind.POSTFIX, operator),
9014 arg,
9015 isSetterValid: false);
9016 }
9017
9018 @override
9019 R visitFinalLocalVariablePrefix(
9020 Send node,
9021 LocalVariableElement variable,
9022 IncDecOperator operator,
9023 A arg) {
9024 return handleLocalCompounds(
9025 node,
9026 variable,
9027 new IncDecCompound(CompoundKind.PREFIX, operator),
9028 arg,
9029 isSetterValid: false);
9030 }
9031
9032 @override
9033 R visitFinalParameterPostfix(
9034 Send node,
9035 ParameterElement parameter,
9036 IncDecOperator operator,
9037 A arg) {
9038 return handleLocalCompounds(
9039 node,
9040 parameter,
9041 new IncDecCompound(CompoundKind.POSTFIX, operator),
9042 arg,
9043 isSetterValid: false);
9044 }
9045
9046 @override
9047 R visitFinalParameterPrefix(
9048 Send node,
9049 ParameterElement parameter,
9050 IncDecOperator operator,
9051 A arg) {
9052 return handleLocalCompounds(
9053 node,
9054 parameter,
9055 new IncDecCompound(CompoundKind.PREFIX, operator),
9056 arg,
9057 isSetterValid: false);
9058 }
9059
9060 @override
9061 R visitFinalStaticFieldPostfix(
9062 Send node,
9063 FieldElement field,
9064 IncDecOperator operator,
9065 A arg) {
9066 return handleStaticCompounds(
9067 node,
9068 field,
9069 CompoundGetter.FIELD,
9070 field,
9071 CompoundSetter.INVALID,
9072 new IncDecCompound(CompoundKind.POSTFIX, operator),
9073 arg);
9074 }
9075
9076 @override
9077 R visitFinalStaticFieldPrefix(
9078 Send node,
9079 FieldElement field,
9080 IncDecOperator operator,
9081 A arg) {
9082 return handleStaticCompounds(
9083 node,
9084 field,
9085 CompoundGetter.FIELD,
9086 field,
9087 CompoundSetter.INVALID,
9088 new IncDecCompound(CompoundKind.PREFIX, operator),
9089 arg);
9090 }
9091
9092 @override
9093 R visitSuperFieldFieldCompound(
9094 Send node,
9095 FieldElement readField,
9096 FieldElement writtenField,
9097 AssignmentOperator operator,
9098 Node rhs,
9099 A arg) {
9100 return handleSuperCompounds(
9101 node,
9102 readField,
9103 CompoundGetter.FIELD,
9104 writtenField,
9105 CompoundSetter.FIELD,
9106 new AssignmentCompound(operator, rhs),
9107 arg);
9108 }
9109
9110 @override
9111 R visitFinalSuperFieldPostfix(
9112 Send node,
9113 FieldElement field,
9114 IncDecOperator operator,
9115 A arg) {
9116 return handleSuperCompounds(
9117 node,
9118 field,
9119 CompoundGetter.FIELD,
9120 field,
9121 CompoundSetter.INVALID,
9122 new IncDecCompound(CompoundKind.POSTFIX, operator),
9123 arg);
9124 }
9125
9126 @override
9127 R visitFinalSuperFieldPrefix(
9128 Send node,
9129 FieldElement field,
9130 IncDecOperator operator,
9131 A arg) {
9132 return handleSuperCompounds(
9133 node,
9134 field,
9135 CompoundGetter.FIELD,
9136 field,
9137 CompoundSetter.INVALID,
9138 new IncDecCompound(CompoundKind.PREFIX, operator),
9139 arg);
9140 }
9141
9142 @override
9143 R visitSuperMethodCompound(
9144 Send node,
9145 FunctionElement method,
9146 AssignmentOperator operator,
9147 Node rhs,
9148 A arg) {
9149 return handleSuperCompounds(
9150 node,
9151 method,
9152 CompoundGetter.METHOD,
9153 method,
9154 CompoundSetter.INVALID,
9155 new AssignmentCompound(operator, rhs),
9156 arg);
9157 }
9158
9159 @override
9160 R visitSuperMethodPostfix(
9161 Send node,
9162 FunctionElement method,
9163 IncDecOperator operator,
9164 A arg) {
9165 return handleSuperCompounds(
9166 node,
9167 method,
9168 CompoundGetter.METHOD,
9169 method,
9170 CompoundSetter.INVALID,
9171 new IncDecCompound(CompoundKind.POSTFIX, operator),
9172 arg);
9173 }
9174
9175 @override
9176 R visitSuperMethodPrefix(
9177 Send node,
9178 FunctionElement method,
9179 IncDecOperator operator,
9180 A arg) {
9181 return handleSuperCompounds(
9182 node,
9183 method,
9184 CompoundGetter.METHOD,
9185 method,
9186 CompoundSetter.INVALID,
9187 new IncDecCompound(CompoundKind.PREFIX, operator),
9188 arg);
9189 }
9190
9191 @override
9192 R visitFinalTopLevelFieldPostfix(
9193 Send node,
9194 FieldElement field,
9195 IncDecOperator operator,
9196 A arg) {
9197 return handleStaticCompounds(
9198 node,
9199 field,
9200 CompoundGetter.FIELD,
9201 field,
9202 CompoundSetter.INVALID,
9203 new IncDecCompound(CompoundKind.POSTFIX, operator),
9204 arg);
9205 }
9206
9207 @override
9208 R visitFinalTopLevelFieldPrefix(
9209 Send node,
9210 FieldElement field,
9211 IncDecOperator operator,
9212 A arg) {
9213 return handleStaticCompounds(
9214 node,
9215 field,
9216 CompoundGetter.FIELD,
9217 field,
9218 CompoundSetter.INVALID,
9219 new IncDecCompound(CompoundKind.PREFIX, operator),
9220 arg);
9221 }
9222
9223 @override
9224 R visitUnresolvedSuperCompound(
9225 Send node,
9226 Element element,
9227 AssignmentOperator operator,
9228 Node rhs,
9229 A arg) {
9230 return handleSuperCompounds(
9231 node,
9232 element,
9233 CompoundGetter.UNRESOLVED,
9234 element,
9235 CompoundSetter.INVALID,
9236 new AssignmentCompound(operator, rhs),
9237 arg);
9238 }
9239
9240 @override
9241 R visitUnresolvedSuperPostfix(
9242 Send node,
9243 Element element,
9244 IncDecOperator operator,
9245 A arg) {
9246 return handleSuperCompounds(
9247 node,
9248 element,
9249 CompoundGetter.UNRESOLVED,
9250 element,
9251 CompoundSetter.INVALID,
9252 new IncDecCompound(CompoundKind.POSTFIX, operator),
9253 arg);
9254 }
9255
9256 @override
9257 R visitUnresolvedSuperPrefix(
9258 Send node,
9259 Element element,
9260 IncDecOperator operator,
9261 A arg) {
9262 return handleSuperCompounds(
9263 node,
9264 element,
9265 CompoundGetter.UNRESOLVED,
9266 element,
9267 CompoundSetter.INVALID,
9268 new IncDecCompound(CompoundKind.PREFIX, operator),
9269 arg);
9270 }
9271
9272 @override
9273 R visitUnresolvedSuperGetterCompound(
9274 Send node, Element element,
9275 MethodElement setter,
9276 AssignmentOperator operator,
9277 Node rhs,
9278 A arg) {
9279 return handleSuperCompounds(
9280 node,
9281 element,
9282 CompoundGetter.UNRESOLVED,
9283 setter,
9284 CompoundSetter.SETTER,
9285 new AssignmentCompound(operator, rhs),
9286 arg);
9287 }
9288
9289 @override
9290 R visitUnresolvedSuperGetterPostfix(
9291 Send node,
9292 Element element,
9293 MethodElement setter,
9294 IncDecOperator operator,
9295 A arg) {
9296 return handleSuperCompounds(
9297 node,
9298 element,
9299 CompoundGetter.UNRESOLVED,
9300 setter,
9301 CompoundSetter.SETTER,
9302 new IncDecCompound(CompoundKind.POSTFIX, operator),
9303 arg);
9304 }
9305
9306 @override
9307 R visitUnresolvedSuperGetterPrefix(
9308 Send node,
9309 Element element,
9310 MethodElement setter,
9311 IncDecOperator operator,
9312 A arg) {
9313 return handleSuperCompounds(
9314 node,
9315 element,
9316 CompoundGetter.UNRESOLVED,
9317 setter,
9318 CompoundSetter.SETTER,
9319 new IncDecCompound(CompoundKind.PREFIX, operator),
9320 arg);
9321 }
9322
9323 @override
9324 R visitUnresolvedSuperSetterCompound(
9325 Send node,
9326 MethodElement getter,
9327 Element element,
9328 AssignmentOperator operator,
9329 Node rhs,
9330 A arg) {
9331 return handleSuperCompounds(
9332 node,
9333 getter,
9334 CompoundGetter.GETTER,
9335 element,
9336 CompoundSetter.INVALID,
9337 new AssignmentCompound(operator, rhs),
9338 arg);
9339 }
9340
9341 @override
9342 R visitUnresolvedSuperSetterPostfix(
9343 Send node,
9344 MethodElement getter,
9345 Element element,
9346 IncDecOperator operator,
9347 A arg) {
9348 return handleSuperCompounds(
9349 node,
9350 getter,
9351 CompoundGetter.GETTER,
9352 element,
9353 CompoundSetter.INVALID,
9354 new IncDecCompound(CompoundKind.POSTFIX, operator),
9355 arg);
9356 }
9357
9358 @override
9359 R visitUnresolvedSuperSetterPrefix(
9360 Send node,
9361 MethodElement getter,
9362 Element element,
9363 IncDecOperator operator,
9364 A arg) {
9365 return handleSuperCompounds(
9366 node,
9367 getter,
9368 CompoundGetter.GETTER,
9369 element,
9370 CompoundSetter.INVALID,
9371 new IncDecCompound(CompoundKind.PREFIX, operator),
9372 arg);
9373 }
9374 }
9375
9376 /// Simplified handling of indexed compound assignments and prefix/postfix
9377 /// expressions.
9378 abstract class BaseImplementationOfIndexCompoundsMixin<R, A>
9379 implements SemanticSendVisitor<R, A> {
9380
9381 /// Handle a dynamic index compounds, like `receiver[index] += rhs` or
9382 /// `--receiver[index]`.
9383 R handleIndexCompounds(
9384 SendSet node,
9385 Node receiver,
9386 Node index,
9387 CompoundRhs rhs,
9388 A arg);
9389
9390 /// Handle a super index compounds, like `super[index] += rhs` or
9391 /// `--super[index]`.
9392 R handleSuperIndexCompounds(
9393 SendSet node,
9394 Element indexFunction,
9395 Element indexSetFunction,
9396 Node index,
9397 CompoundRhs rhs,
9398 A arg,
9399 {bool isGetterValid,
9400 bool isSetterValid});
9401
9402 @override
9403 R visitSuperCompoundIndexSet(
9404 Send node,
9405 FunctionElement indexFunction,
9406 FunctionElement indexSetFunction,
9407 Node index,
9408 AssignmentOperator operator,
9409 Node rhs,
9410 A arg) {
9411 return handleSuperIndexCompounds(
9412 node, indexFunction, indexSetFunction, index,
9413 new AssignmentCompound(operator, rhs), arg,
9414 isGetterValid: true, isSetterValid: true);
9415 }
9416
9417 @override
9418 R visitSuperIndexPostfix(
9419 Send node,
9420 FunctionElement indexFunction,
9421 FunctionElement indexSetFunction,
9422 Node index,
9423 IncDecOperator operator,
9424 A arg) {
9425 return handleSuperIndexCompounds(
9426 node, indexFunction, indexSetFunction, index,
9427 new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
9428 isGetterValid: true, isSetterValid: true);
9429 }
9430
9431 @override
9432 R visitSuperIndexPrefix(
9433 Send node,
9434 FunctionElement indexFunction,
9435 FunctionElement indexSetFunction,
9436 Node index,
9437 IncDecOperator operator,
9438 A arg) {
9439 return handleSuperIndexCompounds(
9440 node, indexFunction, indexSetFunction, index,
9441 new IncDecCompound(CompoundKind.PREFIX, operator), arg,
9442 isGetterValid: true, isSetterValid: true);
9443 }
9444
9445 @override
9446 R visitUnresolvedSuperGetterCompoundIndexSet(
9447 Send node,
9448 Element indexFunction,
9449 FunctionElement indexSetFunction,
9450 Node index,
9451 AssignmentOperator operator,
9452 Node rhs,
9453 A arg) {
9454 return handleSuperIndexCompounds(
9455 node, indexFunction, indexSetFunction, index,
9456 new AssignmentCompound(operator, rhs), arg,
9457 isGetterValid: false, isSetterValid: true);
9458 }
9459
9460 @override
9461 R visitUnresolvedSuperSetterCompoundIndexSet(
9462 Send node,
9463 FunctionElement indexFunction,
9464 Element indexSetFunction,
9465 Node index,
9466 AssignmentOperator operator,
9467 Node rhs,
9468 A arg) {
9469 return handleSuperIndexCompounds(
9470 node, indexFunction, indexSetFunction, index,
9471 new AssignmentCompound(operator, rhs), arg,
9472 isGetterValid: true, isSetterValid: false);
9473 }
9474
9475 @override
9476 R visitUnresolvedSuperCompoundIndexSet(
9477 Send node,
9478 Element element,
9479 Node index,
9480 AssignmentOperator operator,
9481 Node rhs,
9482 A arg) {
9483 return handleSuperIndexCompounds(
9484 node, element, element, index,
9485 new AssignmentCompound(operator, rhs), arg,
9486 isGetterValid: false, isSetterValid: false);
9487 }
9488
9489 @override
9490 R visitUnresolvedSuperGetterIndexPostfix(
9491 Send node,
9492 Element element,
9493 FunctionElement indexSetFunction,
9494 Node index,
9495 IncDecOperator operator,
9496 A arg) {
9497 return handleSuperIndexCompounds(
9498 node, element, indexSetFunction, index,
9499 new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
9500 isGetterValid: false, isSetterValid: true);
9501 }
9502
9503 @override
9504 R visitUnresolvedSuperGetterIndexPrefix(
9505 Send node,
9506 Element element,
9507 FunctionElement indexSetFunction,
9508 Node index,
9509 IncDecOperator operator,
9510 A arg) {
9511 return handleSuperIndexCompounds(
9512 node, element, indexSetFunction, index,
9513 new IncDecCompound(CompoundKind.PREFIX, operator), arg,
9514 isGetterValid: false, isSetterValid: true);
9515 }
9516
9517 @override
9518 R visitUnresolvedSuperSetterIndexPostfix(
9519 Send node,
9520 MethodElement indexFunction,
9521 Element element,
9522 Node index,
9523 IncDecOperator operator,
9524 A arg) {
9525 return handleSuperIndexCompounds(
9526 node, indexFunction, element, index,
9527 new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
9528 isGetterValid: true, isSetterValid: false);
9529 }
9530
9531 @override
9532 R visitUnresolvedSuperSetterIndexPrefix(
9533 Send node,
9534 MethodElement indexFunction,
9535 Element element,
9536 Node index,
9537 IncDecOperator operator,
9538 A arg) {
9539 return handleSuperIndexCompounds(
9540 node, indexFunction, element, index,
9541 new IncDecCompound(CompoundKind.PREFIX, operator), arg,
9542 isGetterValid: true, isSetterValid: false);
9543 }
9544
9545 @override
9546 R visitUnresolvedSuperIndexPostfix(
9547 Send node,
9548 Element element,
9549 Node index,
9550 IncDecOperator operator,
9551 A arg) {
9552 return handleSuperIndexCompounds(
9553 node, element, element, index,
9554 new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
9555 isGetterValid: false, isSetterValid: false);
9556 }
9557
9558 @override
9559 R visitUnresolvedSuperIndexPrefix(
9560 Send node,
9561 Element element,
9562 Node index,
9563 IncDecOperator operator,
9564 A arg) {
9565 return handleSuperIndexCompounds(
9566 node, element, element, index,
9567 new IncDecCompound(CompoundKind.PREFIX, operator), arg,
9568 isGetterValid: false, isSetterValid: false);
9569 }
9570
9571 @override
9572 R visitCompoundIndexSet(
9573 SendSet node,
9574 Node receiver,
9575 Node index,
9576 AssignmentOperator operator,
9577 Node rhs,
9578 A arg) {
9579 return handleIndexCompounds(
9580 node, receiver, index,
9581 new AssignmentCompound(operator, rhs), arg);
9582 }
9583
9584 @override
6398 R visitIndexPostfix( 9585 R visitIndexPostfix(
6399 Send node, 9586 Send node,
6400 Node receiver, 9587 Node receiver,
6401 Node index, 9588 Node index,
6402 IncDecOperator operator, 9589 IncDecOperator operator,
6403 A arg) { 9590 A arg) {
6404 return handleDynamicIndexPostfixPrefix( 9591 return handleIndexCompounds(
6405 node, receiver, index, operator, arg, isPrefix: false); 9592 node, receiver, index,
9593 new IncDecCompound(CompoundKind.POSTFIX, operator), arg);
6406 } 9594 }
6407 9595
6408 @override 9596 @override
6409 R visitIndexPrefix( 9597 R visitIndexPrefix(
6410 Send node, 9598 Send node,
6411 Node receiver, 9599 Node receiver,
6412 Node index, 9600 Node index,
6413 IncDecOperator operator, 9601 IncDecOperator operator,
6414 A arg) { 9602 A arg) {
6415 return handleDynamicIndexPostfixPrefix( 9603 return handleIndexCompounds(
6416 node, receiver, index, operator, arg, isPrefix: true); 9604 node, receiver, index,
9605 new IncDecCompound(CompoundKind.PREFIX, operator), arg);
6417 } 9606 }
6418 } 9607 }
6419 9608
9609
9610
6420 /// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by 9611 /// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by
6421 /// delegating calls to `handleSuperXPostfixPrefix` methods. 9612 /// delegating calls to `handleSuperXPostfixPrefix` methods.
6422 /// 9613 ///
6423 /// This mixin is useful for the cases where super prefix/postfix expression are 9614 /// This mixin is useful for the cases where super prefix/postfix expression are
6424 /// handled uniformly. 9615 /// handled uniformly.
6425 abstract class BaseImplementationOfSuperIncDecsMixin<R, A> 9616 abstract class BaseImplementationOfSuperIncDecsMixin<R, A>
6426 implements SemanticSendVisitor<R, A> { 9617 implements SemanticSendVisitor<R, A> {
6427 R handleSuperFieldFieldPostfixPrefix( 9618 R handleSuperFieldFieldPostfixPrefix(
6428 Send node, 9619 Send node,
6429 FieldElement readField, 9620 FieldElement readField,
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
6469 FunctionElement indexFunction, 9660 FunctionElement indexFunction,
6470 FunctionElement indexSetFunction, 9661 FunctionElement indexSetFunction,
6471 Node index, 9662 Node index,
6472 IncDecOperator operator, 9663 IncDecOperator operator,
6473 A arg, 9664 A arg,
6474 {bool isPrefix}); 9665 {bool isPrefix});
6475 9666
6476 R handleUnresolvedSuperGetterIndexPostfixPrefix( 9667 R handleUnresolvedSuperGetterIndexPostfixPrefix(
6477 Send node, 9668 Send node,
6478 Element element, 9669 Element element,
9670 MethodElement setter,
6479 Node index, 9671 Node index,
6480 IncDecOperator operator, 9672 IncDecOperator operator,
6481 A arg, 9673 A arg,
6482 {bool isPrefix}); 9674 {bool isPrefix});
6483 9675
6484 R handleUnresolvedSuperSetterIndexPostfixPrefix( 9676 R handleUnresolvedSuperSetterIndexPostfixPrefix(
6485 Send node, 9677 Send node,
6486 FunctionElement indexFunction, 9678 FunctionElement indexFunction,
6487 Element element, 9679 Element element,
6488 Node index, 9680 Node index,
6489 IncDecOperator operator, 9681 IncDecOperator operator,
6490 A arg, 9682 A arg,
6491 {bool isPrefix}); 9683 {bool isPrefix});
6492 9684
9685 R handleUnresolvedSuperIndexPostfixPrefix(
9686 Send node,
9687 Element element,
9688 Node index,
9689 IncDecOperator operator,
9690 A arg,
9691 {bool isPrefix});
9692
9693 R handleFinalSuperFieldPostfixPrefix(
9694 Send node,
9695 FieldElement field,
9696 IncDecOperator operator,
9697 A arg,
9698 {bool isPrefix});
9699
9700 R handleSuperMethodPostfixPrefix(
9701 Send node,
9702 MethodElement method,
9703 IncDecOperator operator,
9704 A arg,
9705 {bool isPrefix});
9706
9707 R handleUnresolvedSuperPostfixPrefix(
9708 Send node,
9709 Element element,
9710 IncDecOperator operator,
9711 A arg,
9712 {bool isPrefix});
9713
9714 R handleUnresolvedSuperGetterPostfixPrefix(
9715 Send node,
9716 Element element,
9717 MethodElement setter,
9718 IncDecOperator operator,
9719 A arg,
9720 {bool isPrefix});
9721
9722 R handleUnresolvedSuperSetterPostfixPrefix(
9723 Send node,
9724 MethodElement getter,
9725 Element element,
9726 IncDecOperator operator,
9727 A arg,
9728 {bool isPrefix});
9729
6493 @override 9730 @override
6494 R visitSuperFieldFieldPostfix( 9731 R visitSuperFieldFieldPostfix(
6495 Send node, 9732 Send node,
6496 FieldElement readField, 9733 FieldElement readField,
6497 FieldElement writtenField, 9734 FieldElement writtenField,
6498 IncDecOperator operator, 9735 IncDecOperator operator,
6499 A arg) { 9736 A arg) {
6500 return handleSuperFieldFieldPostfixPrefix( 9737 return handleSuperFieldFieldPostfixPrefix(
6501 node, readField, writtenField, operator, arg, isPrefix: false); 9738 node, readField, writtenField, operator, arg, isPrefix: false);
6502 } 9739 }
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after
6643 A arg) { 9880 A arg) {
6644 return handleSuperIndexPostfixPrefix( 9881 return handleSuperIndexPostfixPrefix(
6645 node, indexFunction, indexSetFunction, 9882 node, indexFunction, indexSetFunction,
6646 index, operator, arg, isPrefix: true); 9883 index, operator, arg, isPrefix: true);
6647 } 9884 }
6648 9885
6649 @override 9886 @override
6650 R visitUnresolvedSuperGetterIndexPostfix( 9887 R visitUnresolvedSuperGetterIndexPostfix(
6651 Send node, 9888 Send node,
6652 Element element, 9889 Element element,
9890 MethodElement setter,
6653 Node index, 9891 Node index,
6654 IncDecOperator operator, 9892 IncDecOperator operator,
6655 A arg) { 9893 A arg) {
6656 return handleUnresolvedSuperGetterIndexPostfixPrefix( 9894 return handleUnresolvedSuperGetterIndexPostfixPrefix(
6657 node, element, index, operator, arg, isPrefix: false); 9895 node, element, setter, index, operator, arg, isPrefix: false);
6658 } 9896 }
6659 9897
6660 @override 9898 @override
6661 R visitUnresolvedSuperGetterIndexPrefix( 9899 R visitUnresolvedSuperGetterIndexPrefix(
6662 Send node, 9900 Send node,
6663 Element element, 9901 Element element,
9902 MethodElement setter,
6664 Node index, 9903 Node index,
6665 IncDecOperator operator, 9904 IncDecOperator operator,
6666 A arg) { 9905 A arg) {
6667 return handleUnresolvedSuperGetterIndexPostfixPrefix( 9906 return handleUnresolvedSuperGetterIndexPostfixPrefix(
6668 node, element, index, operator, arg, isPrefix: true); 9907 node, element, setter, index, operator, arg, isPrefix: true);
6669 } 9908 }
6670 9909
6671 @override 9910 @override
6672 R visitUnresolvedSuperSetterIndexPostfix( 9911 R visitUnresolvedSuperSetterIndexPostfix(
6673 Send node, 9912 Send node,
6674 MethodElement indexFunction, 9913 MethodElement indexFunction,
6675 Element element, 9914 Element element,
6676 Node index, 9915 Node index,
6677 IncDecOperator operator, 9916 IncDecOperator operator,
6678 A arg) { 9917 A arg) {
6679 return handleUnresolvedSuperSetterIndexPostfixPrefix( 9918 return handleUnresolvedSuperSetterIndexPostfixPrefix(
6680 node, indexFunction, element, index, operator, arg, isPrefix: false); 9919 node, indexFunction, element, index, operator, arg, isPrefix: false);
6681 } 9920 }
6682 9921
6683 @override 9922 @override
6684 R visitUnresolvedSuperSetterIndexPrefix( 9923 R visitUnresolvedSuperSetterIndexPrefix(
6685 Send node, 9924 Send node,
6686 MethodElement indexFunction, 9925 MethodElement indexFunction,
6687 Element element, 9926 Element element,
6688 Node index, 9927 Node index,
6689 IncDecOperator operator, 9928 IncDecOperator operator,
6690 A arg) { 9929 A arg) {
6691 return handleUnresolvedSuperSetterIndexPostfixPrefix( 9930 return handleUnresolvedSuperSetterIndexPostfixPrefix(
6692 node, indexFunction, element, index, operator, arg, isPrefix: true); 9931 node, indexFunction, element, index, operator, arg, isPrefix: true);
6693 } 9932 }
9933
9934 @override
9935 R visitUnresolvedSuperIndexPostfix(
9936 Send node,
9937 Element element,
9938 Node index,
9939 IncDecOperator operator,
9940 A arg) {
9941 return handleUnresolvedSuperIndexPostfixPrefix(
9942 node, element, index, operator, arg, isPrefix: false);
9943 }
9944
9945 @override
9946 R visitUnresolvedSuperIndexPrefix(
9947 Send node,
9948 Element element,
9949 Node index,
9950 IncDecOperator operator,
9951 A arg) {
9952 return handleUnresolvedSuperIndexPostfixPrefix(
9953 node, element, index, operator, arg, isPrefix: true);
9954 }
9955
9956 @override
9957 R visitFinalSuperFieldPostfix(
9958 Send node,
9959 FieldElement field,
9960 IncDecOperator operator,
9961 A arg) {
9962 return handleFinalSuperFieldPostfixPrefix(
9963 node, field, operator, arg, isPrefix: false);
9964 }
9965
9966 @override
9967 R visitFinalSuperFieldPrefix(
9968 Send node,
9969 FieldElement field,
9970 IncDecOperator operator,
9971 A arg) {
9972 return handleFinalSuperFieldPostfixPrefix(
9973 node, field, operator, arg, isPrefix: true);
9974 }
9975
9976 @override
9977 R visitSuperMethodPostfix(
9978 Send node,
9979 MethodElement method,
9980 IncDecOperator operator,
9981 A arg) {
9982 return handleSuperMethodPostfixPrefix(
9983 node, method, operator, arg, isPrefix: false);
9984 }
9985
9986 @override
9987 R visitSuperMethodPrefix(
9988 Send node,
9989 MethodElement method,
9990 IncDecOperator operator,
9991 A arg) {
9992 return handleSuperMethodPostfixPrefix(
9993 node, method, operator, arg, isPrefix: true);
9994 }
9995
9996 @override
9997 R visitUnresolvedSuperPostfix(
9998 Send node,
9999 Element element,
10000 IncDecOperator operator,
10001 A arg) {
10002 return handleUnresolvedSuperPostfixPrefix(
10003 node, element, operator, arg, isPrefix: false);
10004 }
10005
10006 @override
10007 R visitUnresolvedSuperPrefix(
10008 Send node,
10009 Element element,
10010 IncDecOperator operator,
10011 A arg) {
10012 return handleUnresolvedSuperPostfixPrefix(
10013 node, element, operator, arg, isPrefix: true);
10014 }
10015
10016 @override
10017 R visitUnresolvedSuperGetterPostfix(
10018 Send node,
10019 Element element,
10020 MethodElement setter,
10021 IncDecOperator operator,
10022 A arg) {
10023 return handleUnresolvedSuperGetterPostfixPrefix(
10024 node, element, setter, operator, arg, isPrefix: false);
10025 }
10026
10027 @override
10028 R visitUnresolvedSuperGetterPrefix(
10029 Send node,
10030 Element element,
10031 MethodElement setter,
10032 IncDecOperator operator,
10033 A arg) {
10034 return handleUnresolvedSuperGetterPostfixPrefix(
10035 node, element, setter, operator, arg, isPrefix: true);
10036 }
10037
10038 @override
10039 R visitUnresolvedSuperSetterPostfix(
10040 Send node,
10041 MethodElement getter,
10042 Element element,
10043 IncDecOperator operator,
10044 A arg) {
10045 return handleUnresolvedSuperSetterPostfixPrefix(
10046 node, getter, element, operator, arg, isPrefix: false);
10047 }
10048
10049 @override
10050 R visitUnresolvedSuperSetterPrefix(
10051 Send node,
10052 MethodElement getter,
10053 Element element,
10054 IncDecOperator operator,
10055 A arg) {
10056 return handleUnresolvedSuperSetterPostfixPrefix(
10057 node, getter, element, operator, arg, isPrefix: true);
10058 }
6694 } 10059 }
6695 10060
6696 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by 10061 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by
6697 /// delegating calls to the `handleConstructorInvoke` method. 10062 /// delegating calls to the `handleConstructorInvoke` method.
6698 /// 10063 ///
6699 /// This mixin is useful for the cases where all constructor invocations are 10064 /// This mixin is useful for the cases where all constructor invocations are
6700 /// handled uniformly. 10065 /// handled uniformly.
6701 abstract class BaseImplementationOfNewMixin<R, A> 10066 abstract class BaseImplementationOfNewMixin<R, A>
6702 implements SemanticSendVisitor<R, A> { 10067 implements SemanticSendVisitor<R, A> {
6703 10068
6704 R handleConstructorInvoke( 10069 R handleConstructorInvoke(
6705 NewExpression node, 10070 NewExpression node,
6706 ConstructorElement constructor, 10071 ConstructorElement constructor,
6707 DartType type, 10072 DartType type,
6708 NodeList arguments, 10073 NodeList arguments,
6709 CallStructure callStructure, 10074 CallStructure callStructure,
6710 A arg); 10075 A arg);
6711 10076
6712 R visitGenerativeConstructorInvoke( 10077 R visitGenerativeConstructorInvoke(
6713 NewExpression node, 10078 NewExpression node,
6714 ConstructorElement constructor, 10079 ConstructorElement constructor,
6715 InterfaceType type, 10080 InterfaceType type,
6716 NodeList arguments, 10081 NodeList arguments,
6717 CallStructure callStructure, 10082 CallStructure callStructure,
6718 A arg) { 10083 A arg) {
6719 return handleConstructorInvoke( 10084 return handleConstructorInvoke(
6720 node, constructor, type, arguments, callStructure, arg); 10085 node, constructor, type, arguments, callStructure, arg);
6721 } 10086 }
6722 10087
10088 @override
6723 R visitRedirectingGenerativeConstructorInvoke( 10089 R visitRedirectingGenerativeConstructorInvoke(
6724 NewExpression node, 10090 NewExpression node,
6725 ConstructorElement constructor, 10091 ConstructorElement constructor,
6726 InterfaceType type, 10092 InterfaceType type,
6727 NodeList arguments, 10093 NodeList arguments,
6728 CallStructure callStructure, 10094 CallStructure callStructure,
6729 A arg) { 10095 A arg) {
6730 return handleConstructorInvoke( 10096 return handleConstructorInvoke(
6731 node, constructor, type, arguments, callStructure, arg); 10097 node, constructor, type, arguments, callStructure, arg);
6732 } 10098 }
6733 10099
10100 @override
6734 R visitFactoryConstructorInvoke( 10101 R visitFactoryConstructorInvoke(
6735 NewExpression node, 10102 NewExpression node,
6736 ConstructorElement constructor, 10103 ConstructorElement constructor,
6737 InterfaceType type, 10104 InterfaceType type,
6738 NodeList arguments, 10105 NodeList arguments,
6739 CallStructure callStructure, 10106 CallStructure callStructure,
6740 A arg) { 10107 A arg) {
6741 return handleConstructorInvoke( 10108 return handleConstructorInvoke(
6742 node, constructor, type, arguments, callStructure, arg); 10109 node, constructor, type, arguments, callStructure, arg);
6743 } 10110 }
6744 10111
10112 @override
6745 R visitRedirectingFactoryConstructorInvoke( 10113 R visitRedirectingFactoryConstructorInvoke(
6746 NewExpression node, 10114 NewExpression node,
6747 ConstructorElement constructor, 10115 ConstructorElement constructor,
6748 InterfaceType type, 10116 InterfaceType type,
6749 ConstructorElement effectiveTarget, 10117 ConstructorElement effectiveTarget,
6750 InterfaceType effectiveTargetType, 10118 InterfaceType effectiveTargetType,
6751 NodeList arguments, 10119 NodeList arguments,
6752 CallStructure callStructure, 10120 CallStructure callStructure,
6753 A arg) { 10121 A arg) {
6754 return handleConstructorInvoke( 10122 return handleConstructorInvoke(
6755 node, constructor, type, arguments, callStructure, arg); 10123 node, constructor, type, arguments, callStructure, arg);
6756 } 10124 }
6757 10125
10126 @override
6758 R visitUnresolvedConstructorInvoke( 10127 R visitUnresolvedConstructorInvoke(
6759 NewExpression node, 10128 NewExpression node,
6760 Element constructor, 10129 Element constructor,
6761 DartType type, 10130 DartType type,
6762 NodeList arguments, 10131 NodeList arguments,
6763 Selector selector, 10132 Selector selector,
6764 A arg) { 10133 A arg) {
6765 return handleConstructorInvoke( 10134 return handleConstructorInvoke(
6766 node, constructor, type, arguments, selector.callStructure, arg); 10135 node, constructor, type, arguments, selector.callStructure, arg);
6767 } 10136 }
6768 10137
10138 @override
6769 R visitUnresolvedClassConstructorInvoke( 10139 R visitUnresolvedClassConstructorInvoke(
6770 NewExpression node, 10140 NewExpression node,
6771 Element element, 10141 Element element,
6772 DartType type, 10142 DartType type,
6773 NodeList arguments, 10143 NodeList arguments,
6774 Selector selector, 10144 Selector selector,
6775 A arg) { 10145 A arg) {
6776 return handleConstructorInvoke( 10146 return handleConstructorInvoke(
6777 node, element, type, arguments, selector.callStructure, arg); 10147 node, element, type, arguments, selector.callStructure, arg);
6778 } 10148 }
6779 10149
10150 @override
6780 R visitAbstractClassConstructorInvoke( 10151 R visitAbstractClassConstructorInvoke(
6781 NewExpression node, 10152 NewExpression node,
6782 ConstructorElement constructor, 10153 ConstructorElement constructor,
6783 InterfaceType type, 10154 InterfaceType type,
6784 NodeList arguments, 10155 NodeList arguments,
6785 CallStructure callStructure, 10156 CallStructure callStructure,
6786 A arg) { 10157 A arg) {
6787 return handleConstructorInvoke( 10158 return handleConstructorInvoke(
6788 node, constructor, type, arguments, callStructure, arg); 10159 node, constructor, type, arguments, callStructure, arg);
6789 } 10160 }
10161
10162 @override
6790 R visitUnresolvedRedirectingFactoryConstructorInvoke( 10163 R visitUnresolvedRedirectingFactoryConstructorInvoke(
6791 NewExpression node, 10164 NewExpression node,
6792 ConstructorElement constructor, 10165 ConstructorElement constructor,
6793 InterfaceType type, 10166 InterfaceType type,
6794 NodeList arguments, 10167 NodeList arguments,
6795 CallStructure callStructure, 10168 CallStructure callStructure,
6796 A arg) { 10169 A arg) {
6797 return handleConstructorInvoke( 10170 return handleConstructorInvoke(
6798 node, constructor, type, arguments, callStructure, arg); 10171 node, constructor, type, arguments, callStructure, arg);
6799 } 10172 }
6800 } 10173 }
OLDNEW
« pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart ('K') | « 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