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

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: Refactor 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/resolution/semantic_visitor.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 217 matching lines...) Expand 10 before | Expand all | Expand 10 after
691 472
692 @override 473 @override
693 R visitTopLevelMethodSetterPrefix( 474 R visitTopLevelMethodSetterPrefix(
694 Send node, 475 Send node,
695 FunctionElement method, 476 FunctionElement method,
696 FunctionElement setter, 477 FunctionElement setter,
697 IncDecOperator operator, 478 IncDecOperator operator,
698 A arg) { 479 A arg) {
699 return bulkHandlePrefix(node, arg); 480 return bulkHandlePrefix(node, arg);
700 } 481 }
482
483 @override
484 R visitClassTypeLiteralPrefix(
485 Send node,
486 ConstantExpression constant,
487 IncDecOperator operator,
488 A arg) {
489 return bulkHandlePrefix(node, arg);
490 }
491
492 @override
493 R visitDynamicTypeLiteralPrefix(
494 Send node,
495 ConstantExpression constant,
496 IncDecOperator operator,
497 A arg) {
498 return bulkHandlePrefix(node, arg);
499 }
500
501 @override
502 R visitLocalFunctionPrefix(
503 Send node,
504 LocalFunctionElement function,
505 IncDecOperator operator,
506 A arg) {
507 return bulkHandlePrefix(node, arg);
508 }
509
510 @override
511 R visitTypeVariableTypeLiteralPrefix(
512 Send node,
513 TypeVariableElement element,
514 IncDecOperator operator,
515 A arg) {
516 return bulkHandlePrefix(node, arg);
517 }
518
519 @override
520 R visitTypedefTypeLiteralPrefix(
521 Send node,
522 ConstantExpression constant,
523 IncDecOperator operator,
524 A arg) {
525 return bulkHandlePrefix(node, arg);
526 }
527
528 @override
529 R visitUnresolvedStaticGetterPrefix(
530 Send node,
531 Element element,
532 MethodElement setter,
533 IncDecOperator operator,
534 A arg) {
535 return bulkHandlePrefix(node, arg);
536 }
537
538 @override
539 R visitUnresolvedTopLevelGetterPrefix(
540 Send node,
541 Element element,
542 MethodElement setter,
543 IncDecOperator operator,
544 A arg) {
545 return bulkHandlePrefix(node, arg);
546 }
547
548 @override
549 R visitUnresolvedStaticSetterPrefix(
550 Send node,
551 MethodElement getter,
552 Element element,
553 IncDecOperator operator,
554 A arg) {
555 return bulkHandlePrefix(node, arg);
556 }
557
558 @override
559 R visitUnresolvedTopLevelSetterPrefix(
560 Send node,
561 MethodElement getter,
562 Element element,
563 IncDecOperator operator,
564 A arg) {
565 return bulkHandlePrefix(node, arg);
566 }
567
568 @override
569 R visitStaticMethodPrefix(
570 Send node,
571 MethodElement method,
572 IncDecOperator operator,
573 A arg) {
574 return bulkHandlePrefix(node, arg);
575 }
576
577 @override
578 R visitTopLevelMethodPrefix(
579 Send node,
580 MethodElement method,
581 IncDecOperator operator,
582 A arg) {
583 return bulkHandlePrefix(node, arg);
584 }
585
586 @override
587 R visitUnresolvedPrefix(
588 Send node,
589 Element element,
590 IncDecOperator operator,
591 A arg) {
592 return bulkHandlePrefix(node, arg);
593 }
594
595 @override
596 R visitFinalLocalVariablePrefix(
597 Send node,
598 LocalVariableElement variable,
599 IncDecOperator operator,
600 A arg) {
601 return bulkHandlePrefix(node, arg);
602 }
603
604 @override
605 R visitFinalParameterPrefix(
606 Send node,
607 ParameterElement parameter,
608 IncDecOperator operator,
609 A arg) {
610 return bulkHandlePrefix(node, arg);
611 }
612
613 @override
614 R visitStaticFinalFieldPrefix(
615 Send node,
616 FieldElement field,
617 IncDecOperator operator,
618 A arg) {
619 return bulkHandlePrefix(node, arg);
620 }
621
622 @override
623 R visitSuperFinalFieldPrefix(
624 Send node,
625 FieldElement field,
626 IncDecOperator operator,
627 A arg) {
628 return bulkHandlePrefix(node, arg);
629 }
630
631 @override
632 R visitSuperMethodPrefix(
633 Send node,
634 FunctionElement method,
635 IncDecOperator operator,
636 A arg) {
637 return bulkHandlePrefix(node, arg);
638 }
639
640 @override
641 R visitTopLevelFinalFieldPrefix(
642 Send node,
643 FieldElement field,
644 IncDecOperator operator,
645 A arg) {
646 return bulkHandlePrefix(node, arg);
647 }
648
649 @override
650 R visitUnresolvedSuperPrefix(
651 Send node,
652 Element element,
653 IncDecOperator operator,
654 A arg) {
655 return bulkHandlePrefix(node, arg);
656 }
657
658 @override
659 R visitUnresolvedSuperGetterPrefix(
660 Send node,
661 Element element,
662 MethodElement setter,
663 IncDecOperator operator,
664 A arg) {
665 return bulkHandlePrefix(node, arg);
666 }
667
668 @override
669 R visitUnresolvedSuperSetterPrefix(
670 Send node,
671 MethodElement getter,
672 Element element,
673 IncDecOperator operator,
674 A arg) {
675 return bulkHandlePrefix(node, arg);
676 }
701 } 677 }
702 678
703 /// Mixin that implements all `visitXPostfix` methods of [SemanticSendVisitor] 679 /// Mixin that implements all `visitXPostfix` methods of [SemanticSendVisitor]
704 /// by delegating to a bulk handler. 680 /// by delegating to a bulk handler.
705 /// 681 ///
706 /// Use this mixin to provide a trivial implementation for all `visitXPostfix` 682 /// Use this mixin to provide a trivial implementation for all `visitXPostfix`
707 /// methods. 683 /// methods.
708 abstract class PostfixBulkMixin<R, A> 684 abstract class PostfixBulkMixin<R, A>
709 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 685 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
710 686
(...skipping 191 matching lines...) Expand 10 before | Expand all | Expand 10 after
902 878
903 @override 879 @override
904 R visitTopLevelMethodSetterPostfix( 880 R visitTopLevelMethodSetterPostfix(
905 Send node, 881 Send node,
906 FunctionElement method, 882 FunctionElement method,
907 FunctionElement setter, 883 FunctionElement setter,
908 IncDecOperator operator, 884 IncDecOperator operator,
909 A arg) { 885 A arg) {
910 return bulkHandlePostfix(node, arg); 886 return bulkHandlePostfix(node, arg);
911 } 887 }
888
889 @override
890 R visitClassTypeLiteralPostfix(
891 Send node,
892 ConstantExpression constant,
893 IncDecOperator operator,
894 A arg) {
895 return bulkHandlePostfix(node, arg);
896 }
897
898 @override
899 R visitDynamicTypeLiteralPostfix(
900 Send node,
901 ConstantExpression constant,
902 IncDecOperator operator,
903 A arg) {
904 return bulkHandlePostfix(node, arg);
905 }
906
907 @override
908 R visitLocalFunctionPostfix(
909 Send node,
910 LocalFunctionElement function,
911 IncDecOperator operator,
912 A arg) {
913 return bulkHandlePostfix(node, arg);
914 }
915
916 @override
917 R visitTypeVariableTypeLiteralPostfix(
918 Send node,
919 TypeVariableElement element,
920 IncDecOperator operator,
921 A arg) {
922 return bulkHandlePostfix(node, arg);
923 }
924
925 @override
926 R visitTypedefTypeLiteralPostfix(
927 Send node,
928 ConstantExpression constant,
929 IncDecOperator operator,
930 A arg) {
931 return bulkHandlePostfix(node, arg);
932 }
933
934 @override
935 R visitUnresolvedStaticGetterPostfix(
936 Send node,
937 Element element,
938 MethodElement setter,
939 IncDecOperator operator,
940 A arg) {
941 return bulkHandlePostfix(node, arg);
942 }
943
944 @override
945 R visitUnresolvedTopLevelGetterPostfix(
946 Send node,
947 Element element,
948 MethodElement setter,
949 IncDecOperator operator,
950 A arg) {
951 return bulkHandlePostfix(node, arg);
952 }
953
954 @override
955 R visitUnresolvedStaticSetterPostfix(
956 Send node,
957 MethodElement getter,
958 Element element,
959 IncDecOperator operator,
960 A arg) {
961 return bulkHandlePostfix(node, arg);
962 }
963
964 @override
965 R visitUnresolvedTopLevelSetterPostfix(
966 Send node,
967 MethodElement getter,
968 Element element,
969 IncDecOperator operator,
970 A arg) {
971 return bulkHandlePostfix(node, arg);
972 }
973
974 @override
975 R visitStaticMethodPostfix(
976 Send node,
977 MethodElement method,
978 IncDecOperator operator,
979 A arg) {
980 return bulkHandlePostfix(node, arg);
981 }
982
983 R visitToplevelMethodPostfix(
984 Send node,
985 MethodElement method,
986 IncDecOperator operator,
987 A arg) {
988 return bulkHandlePostfix(node, arg);
989 }
990
991 @override
992 R visitUnresolvedPostfix(
993 Send node,
994 Element element,
995 IncDecOperator operator,
996 A arg) {
997 return bulkHandlePostfix(node, arg);
998 }
999
1000 @override
1001 R visitFinalLocalVariablePostfix(
1002 Send node,
1003 LocalVariableElement variable,
1004 IncDecOperator operator,
1005 A arg) {
1006 return bulkHandlePostfix(node, arg);
1007 }
1008
1009 @override
1010 R visitFinalParameterPostfix(
1011 Send node,
1012 ParameterElement parameter,
1013 IncDecOperator operator,
1014 A arg) {
1015 return bulkHandlePostfix(node, arg);
1016 }
1017
1018 @override
1019 R visitStaticFinalFieldPostfix(
1020 Send node,
1021 FieldElement field,
1022 IncDecOperator operator,
1023 A arg) {
1024 return bulkHandlePostfix(node, arg);
1025 }
1026
1027 @override
1028 R visitSuperFinalFieldPostfix(
1029 Send node,
1030 FieldElement field,
1031 IncDecOperator operator,
1032 A arg) {
1033 return bulkHandlePostfix(node, arg);
1034 }
1035
1036 @override
1037 R visitSuperMethodPostfix(
1038 Send node,
1039 FunctionElement method,
1040 IncDecOperator operator,
1041 A arg) {
1042 return bulkHandlePostfix(node, arg);
1043 }
1044
1045 @override
1046 R visitTopLevelFinalFieldPostfix(
1047 Send node,
1048 FieldElement field,
1049 IncDecOperator operator,
1050 A arg) {
1051 return bulkHandlePostfix(node, arg);
1052 }
1053
1054 @override
1055 R visitTopLevelMethodPostfix(
1056 Send node,
1057 MethodElement method,
1058 IncDecOperator operator,
1059 A arg) {
1060 return bulkHandlePostfix(node, arg);
1061 }
1062
1063 @override
1064 R visitUnresolvedSuperPostfix(
1065 Send node,
1066 Element element,
1067 IncDecOperator operator,
1068 A arg) {
1069 return bulkHandlePostfix(node, arg);
1070 }
1071
1072 @override
1073 R visitUnresolvedSuperGetterPostfix(
1074 Send node,
1075 Element element,
1076 MethodElement setter,
1077 IncDecOperator operator,
1078 A arg) {
1079 return bulkHandlePostfix(node, arg);
1080 }
1081
1082 @override
1083 R visitUnresolvedSuperSetterPostfix(
1084 Send node,
1085 MethodElement getter,
1086 Element element,
1087 IncDecOperator operator,
1088 A arg) {
1089 return bulkHandlePostfix(node, arg);
1090 }
912 } 1091 }
913 1092
914 /// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor] 1093 /// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor]
915 /// by delegating to a bulk handler. 1094 /// by delegating to a bulk handler.
916 /// 1095 ///
917 /// Use this mixin to provide a trivial implementation for all `xCompound` 1096 /// Use this mixin to provide a trivial implementation for all `xCompound`
918 /// methods. 1097 /// methods.
919 abstract class CompoundBulkMixin<R, A> 1098 abstract class CompoundBulkMixin<R, A>
920 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 1099 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
921 1100
(...skipping 154 matching lines...) Expand 10 before | Expand all | Expand 10 after
1076 @override 1255 @override
1077 R visitTopLevelMethodSetterCompound( 1256 R visitTopLevelMethodSetterCompound(
1078 Send node, 1257 Send node,
1079 FunctionElement method, 1258 FunctionElement method,
1080 FunctionElement setter, 1259 FunctionElement setter,
1081 AssignmentOperator operator, 1260 AssignmentOperator operator,
1082 Node rhs, 1261 Node rhs,
1083 A arg) { 1262 A arg) {
1084 return bulkHandleCompound(node, arg); 1263 return bulkHandleCompound(node, arg);
1085 } 1264 }
1265
1266 @override
1267 R visitFinalParameterCompound(
1268 Send node,
1269 ParameterElement parameter,
1270 AssignmentOperator operator,
1271 Node rhs,
1272 A arg) {
1273 return bulkHandleCompound(node, arg);
1274 }
1275
1276 @override
1277 R visitClassTypeLiteralCompound(
1278 Send node,
1279 ConstantExpression constant,
1280 AssignmentOperator operator,
1281 Node rhs,
1282 A arg) {
1283 return bulkHandleCompound(node, arg);
1284 }
1285
1286 @override
1287 R visitDynamicTypeLiteralCompound(
1288 Send node,
1289 ConstantExpression constant,
1290 AssignmentOperator operator,
1291 Node rhs,
1292 A arg) {
1293 return bulkHandleCompound(node, arg);
1294 }
1295
1296 @override
1297 R visitFinalLocalVariableCompound(
1298 Send node,
1299 LocalVariableElement
1300 variable,
1301 AssignmentOperator operator,
1302 Node rhs,
1303 A arg) {
1304 return bulkHandleCompound(node, arg);
1305 }
1306
1307 @override
1308 R visitStaticFinalFieldCompound(
1309 Send node,
1310 FieldElement field,
1311 AssignmentOperator operator,
1312 Node rhs,
1313 A arg) {
1314 return bulkHandleCompound(node, arg);
1315 }
1316
1317 @override
1318 R visitSuperFinalFieldCompound(
1319 Send node,
1320 FieldElement field,
1321 AssignmentOperator operator,
1322 Node rhs,
1323 A arg) {
1324 return bulkHandleCompound(node, arg);
1325 }
1326
1327 @override
1328 R visitTopLevelFinalFieldCompound(
1329 Send node,
1330 FieldElement field,
1331 AssignmentOperator operator,
1332 Node rhs,
1333 A arg) {
1334 return bulkHandleCompound(node, arg);
1335 }
1336
1337 @override
1338 R visitLocalFunctionCompound(
1339 Send node,
1340 LocalFunctionElement function,
1341 AssignmentOperator operator,
1342 Node rhs,
1343 A arg) {
1344 return bulkHandleCompound(node, arg);
1345 }
1346
1347 @override
1348 R visitTypeVariableTypeLiteralCompound(
1349 Send node,
1350 TypeVariableElement element,
1351 AssignmentOperator operator,
1352 Node rhs,
1353 A arg) {
1354 return bulkHandleCompound(node, arg);
1355 }
1356
1357 @override
1358 R visitTypedefTypeLiteralCompound(
1359 Send node,
1360 ConstantExpression constant,
1361 AssignmentOperator operator,
1362 Node rhs,
1363 A arg) {
1364 return bulkHandleCompound(node, arg);
1365 }
1366
1367 @override
1368 R visitUnresolvedStaticGetterCompound(
1369 Send node,
1370 Element element,
1371 MethodElement setter,
1372 AssignmentOperator operator,
1373 Node rhs,
1374 A arg) {
1375 return bulkHandleCompound(node, arg);
1376 }
1377
1378 @override
1379 R visitUnresolvedTopLevelGetterCompound(
1380 Send node,
1381 Element element,
1382 MethodElement setter,
1383 AssignmentOperator operator,
1384 Node rhs,
1385 A arg) {
1386 return bulkHandleCompound(node, arg);
1387 }
1388
1389 @override
1390 R visitUnresolvedStaticSetterCompound(
1391 Send node,
1392 MethodElement getter,
1393 Element element,
1394 AssignmentOperator operator,
1395 Node rhs,
1396 A arg) {
1397 return bulkHandleCompound(node, arg);
1398 }
1399
1400 @override
1401 R visitUnresolvedTopLevelSetterCompound(
1402 Send node,
1403 MethodElement getter,
1404 Element element,
1405 AssignmentOperator operator,
1406 Node rhs,
1407 A arg) {
1408 return bulkHandleCompound(node, arg);
1409 }
1410
1411 @override
1412 R visitStaticMethodCompound(
1413 Send node,
1414 MethodElement method,
1415 AssignmentOperator operator,
1416 Node rhs,
1417 A arg) {
1418 return bulkHandleCompound(node, arg);
1419 }
1420
1421 @override
1422 R visitTopLevelMethodCompound(
1423 Send node,
1424 MethodElement method,
1425 AssignmentOperator operator,
1426 Node rhs,
1427 A arg) {
1428 return bulkHandleCompound(node, arg);
1429 }
1430
1431 @override
1432 R visitUnresolvedCompound(
1433 Send node,
1434 Element element,
1435 AssignmentOperator operator,
1436 Node rhs,
1437 A arg) {
1438 return bulkHandleCompound(node, arg);
1439 }
1440
1441 @override
1442 R visitSuperFieldFieldCompound(
1443 Send node, FieldElement readField,
1444 FieldElement writtenField,
1445 AssignmentOperator operator,
1446 Node rhs,
1447 A arg) {
1448 return bulkHandleCompound(node, arg);
1449 }
1450
1451 @override
1452 R visitSuperMethodCompound(
1453 Send node,
1454 FunctionElement method,
1455 AssignmentOperator operator,
1456 Node rhs,
1457 A arg) {
1458 return bulkHandleCompound(node, arg);
1459 }
1460
1461 @override
1462 R visitUnresolvedSuperCompound(
1463 Send node,
1464 Element element,
1465 AssignmentOperator operator,
1466 Node rhs,
1467 A arg) {
1468 return bulkHandleCompound(node, arg);
1469 }
1470
1471 @override
1472 R visitUnresolvedSuperGetterCompound(
1473 Send node, Element element,
1474 MethodElement setter,
1475 AssignmentOperator operator,
1476 Node rhs,
1477 A arg) {
1478 return bulkHandleCompound(node, arg);
1479 }
1480
1481 @override
1482 R visitUnresolvedSuperSetterCompound(
1483 Send node, MethodElement getter,
1484 Element element,
1485 AssignmentOperator operator,
1486 Node rhs,
1487 A arg) {
1488 return bulkHandleCompound(node, arg);
1489 }
1086 } 1490 }
1087 1491
1088 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by 1492 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by
1089 /// delegating to a bulk handler. 1493 /// delegating to a bulk handler.
1090 /// 1494 ///
1091 /// Use this mixin to provide a trivial implementation for all `visitXInvoke` 1495 /// Use this mixin to provide a trivial implementation for all `visitXInvoke`
1092 /// methods. 1496 /// methods.
1093 abstract class InvokeBulkMixin<R, A> 1497 abstract class InvokeBulkMixin<R, A>
1094 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 1498 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
1095 1499
(...skipping 1258 matching lines...) Expand 10 before | Expand all | Expand 10 after
2354 } 2758 }
2355 2759
2356 @override 2760 @override
2357 R visitConstConstructorInvoke( 2761 R visitConstConstructorInvoke(
2358 NewExpression node, 2762 NewExpression node,
2359 ConstructedConstantExpression constant, 2763 ConstructedConstantExpression constant,
2360 A arg) { 2764 A arg) {
2361 return bulkHandleNew(node, arg); 2765 return bulkHandleNew(node, arg);
2362 } 2766 }
2363 2767
2768 @override
2364 R visitGenerativeConstructorInvoke( 2769 R visitGenerativeConstructorInvoke(
2365 NewExpression node, 2770 NewExpression node,
2366 ConstructorElement constructor, 2771 ConstructorElement constructor,
2367 InterfaceType type, 2772 InterfaceType type,
2368 NodeList arguments, 2773 NodeList arguments,
2369 CallStructure callStructure, 2774 CallStructure callStructure,
2370 A arg) { 2775 A arg) {
2371 return bulkHandleNew(node, arg); 2776 return bulkHandleNew(node, arg);
2372 } 2777 }
2373 2778
2779 @override
2374 R visitRedirectingGenerativeConstructorInvoke( 2780 R visitRedirectingGenerativeConstructorInvoke(
2375 NewExpression node, 2781 NewExpression node,
2376 ConstructorElement constructor, 2782 ConstructorElement constructor,
2377 InterfaceType type, 2783 InterfaceType type,
2378 NodeList arguments, 2784 NodeList arguments,
2379 CallStructure callStructure, 2785 CallStructure callStructure,
2380 A arg) { 2786 A arg) {
2381 return bulkHandleNew(node, arg); 2787 return bulkHandleNew(node, arg);
2382 } 2788 }
2383 2789
2790 @override
2384 R visitFactoryConstructorInvoke( 2791 R visitFactoryConstructorInvoke(
2385 NewExpression node, 2792 NewExpression node,
2386 ConstructorElement constructor, 2793 ConstructorElement constructor,
2387 InterfaceType type, 2794 InterfaceType type,
2388 NodeList arguments, 2795 NodeList arguments,
2389 CallStructure callStructure, 2796 CallStructure callStructure,
2390 A arg) { 2797 A arg) {
2391 return bulkHandleNew(node, arg); 2798 return bulkHandleNew(node, arg);
2392 } 2799 }
2393 2800
2801 @override
2394 R visitRedirectingFactoryConstructorInvoke( 2802 R visitRedirectingFactoryConstructorInvoke(
2395 NewExpression node, 2803 NewExpression node,
2396 ConstructorElement constructor, 2804 ConstructorElement constructor,
2397 InterfaceType type, 2805 InterfaceType type,
2398 ConstructorElement effectiveTarget, 2806 ConstructorElement effectiveTarget,
2399 InterfaceType effectiveTargetType, 2807 InterfaceType effectiveTargetType,
2400 NodeList arguments, 2808 NodeList arguments,
2401 CallStructure callStructure, 2809 CallStructure callStructure,
2402 A arg) { 2810 A arg) {
2403 return bulkHandleNew(node, arg); 2811 return bulkHandleNew(node, arg);
(...skipping 558 matching lines...) Expand 10 before | Expand all | Expand 10 after
2962 return null; 3370 return null;
2963 } 3371 }
2964 3372
2965 @override 3373 @override
2966 R errorDynamicTypeLiteralSet( 3374 R errorDynamicTypeLiteralSet(
2967 SendSet node, 3375 SendSet node,
2968 ConstantExpression constant, 3376 ConstantExpression constant,
2969 Node rhs, 3377 Node rhs,
2970 A arg) { 3378 A arg) {
2971 apply(rhs, arg); 3379 apply(rhs, arg);
2972 return null; 3380 return null;
karlklose 2015/05/13 07:25:59 Remove 'return null'?
Johnni Winther 2015/05/13 08:48:00 It would add a hint of missing return :(
2973 } 3381 }
2974 3382
2975 @override 3383 @override
2976 R errorFinalLocalVariableCompound( 3384 R visitFinalLocalVariableCompound(
2977 Send node, 3385 Send node,
2978 LocalVariableElement variable, 3386 LocalVariableElement variable,
2979 AssignmentOperator operator, 3387 AssignmentOperator operator,
2980 Node rhs, 3388 Node rhs,
2981 A arg) { 3389 A arg) {
2982 apply(rhs, arg); 3390 apply(rhs, arg);
2983 return null; 3391 return null;
2984 } 3392 }
2985 3393
2986 @override 3394 @override
2987 R errorFinalLocalVariableSet( 3395 R errorFinalLocalVariableSet(
2988 SendSet node, 3396 SendSet node,
2989 LocalVariableElement variable, 3397 LocalVariableElement variable,
2990 Node rhs, 3398 Node rhs,
2991 A arg) { 3399 A arg) {
2992 apply(rhs, arg); 3400 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;
3711 }
3712
3713 @override
3714 R visitParameterGet(
3715 Send node,
3716 ParameterElement parameter,
3717 A arg) {
3718 return null;
3719 }
3720
3721 @override
3722 R visitParameterInvoke(
3723 Send node,
3724 ParameterElement parameter,
3725 NodeList arguments,
3726 CallStructure callStructure,
3727 A arg) {
3728 apply(arguments, arg);
3729 return null;
3730 }
3731
3732 @override
3733 R visitParameterPostfix(
3734 Send node,
3735 ParameterElement parameter,
3736 IncDecOperator operator,
3737 A arg) {
3738 return null;
3739 }
3740
3741 @override
3742 R visitParameterPrefix(
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,
3753 ParameterElement parameter,
3754 Node rhs,
3755 A arg) {
3756 apply(rhs, arg);
3757 return null; 3401 return null;
3758 } 3402 }
3759 3403
3760 @override 3404 @override
3761 R visitStaticFieldCompound( 3405 R visitFinalParameterCompound(
3762 Send node, 3406 Send node,
3763 FieldElement field, 3407 ParameterElement parameter,
3764 AssignmentOperator operator, 3408 AssignmentOperator operator,
3765 Node rhs, 3409 Node rhs,
3766 A arg) { 3410 A arg) {
3767 apply(rhs, arg); 3411 apply(rhs, arg);
3768 return null; 3412 return null;
3769 } 3413 }
3770 3414
3771 @override 3415 @override
3772 R visitStaticFieldGet( 3416 R errorFinalParameterSet(
3773 Send node, 3417 SendSet node,
3774 FieldElement field, 3418 ParameterElement parameter,
3419 Node rhs,
3775 A arg) { 3420 A arg) {
3421 apply(rhs, arg);
3776 return null; 3422 return null;
3777 } 3423 }
3778 3424
3779 @override 3425 @override
3780 R visitStaticFieldInvoke( 3426 R visitStaticFinalFieldCompound(
3781 Send node, 3427 Send node,
3782 FieldElement field, 3428 FieldElement field,
3783 NodeList arguments, 3429 AssignmentOperator operator,
3784 CallStructure callStructure, 3430 Node rhs,
3785 A arg) { 3431 A arg) {
3786 apply(arguments, arg); 3432 apply(rhs, arg);
3787 return null; 3433 return null;
3788 } 3434 }
3789 3435
3790 @override 3436 @override
3791 R visitStaticFieldPostfix( 3437 R errorFinalStaticFieldSet(
3792 Send node, 3438 SendSet node,
3793 FieldElement field, 3439 FieldElement field,
3794 IncDecOperator operator, 3440 Node rhs,
3795 A arg) { 3441 A arg) {
3442 apply(rhs, arg);
3796 return null; 3443 return null;
3797 } 3444 }
3798 3445
3799 @override 3446 @override
3800 R visitStaticFieldPrefix( 3447 R errorFinalSuperFieldSet(
3801 Send node, 3448 SendSet node,
3802 FieldElement field, 3449 FieldElement field,
3803 IncDecOperator operator, 3450 Node rhs,
3804 A arg) { 3451 A arg) {
3452 apply(rhs, arg);
3805 return null; 3453 return null;
3806 } 3454 }
3807 3455
3808 @override 3456 @override
3809 R visitStaticFieldSet( 3457 R visitTopLevelFinalFieldCompound(
3458 Send node,
3459 FieldElement field,
3460 AssignmentOperator operator,
3461 Node rhs,
3462 A arg) {
3463 apply(rhs, arg);
3464 return null;
3465 }
3466
3467 @override
3468 R errorFinalTopLevelFieldSet(
3810 SendSet node, 3469 SendSet node,
3811 FieldElement field, 3470 FieldElement field,
3812 Node rhs, 3471 Node rhs,
3813 A arg) { 3472 A arg) {
3814 apply(rhs, arg); 3473 apply(rhs, arg);
3815 return null; 3474 return null;
3816 } 3475 }
3817 3476
3818 @override 3477 @override
3819 R visitStaticFunctionGet( 3478 R visitLocalFunctionCompound(
3820 Send node, 3479 Send node,
3821 MethodElement function, 3480 LocalFunctionElement function,
3481 AssignmentOperator operator,
3482 Node rhs,
3483 A arg) {
3484 apply(rhs, arg);
3485 return null;
3486 }
3487
3488 @override
3489 R visitLocalFunctionPostfix(
3490 Send node,
3491 LocalFunctionElement function,
3492 IncDecOperator operator,
3822 A arg) { 3493 A arg) {
3823 return null; 3494 return null;
3824 } 3495 }
3825 3496
3826 @override 3497 @override
3827 R visitStaticFunctionInvoke( 3498 R visitLocalFunctionPrefix(
3828 Send node, 3499 Send node,
3829 MethodElement function, 3500 LocalFunctionElement function,
3830 NodeList arguments, 3501 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) { 3502 A arg) {
3853 return null; 3503 return null;
3854 } 3504 }
3855 3505
3856 @override 3506 @override
3857 R visitStaticGetterInvoke( 3507 R errorLocalFunctionSet(
3858 Send node, 3508 SendSet node,
3859 FunctionElement getter, 3509 LocalFunctionElement function,
3860 NodeList arguments, 3510 Node rhs,
3861 CallStructure callStructure,
3862 A arg) { 3511 A arg) {
3863 apply(arguments, arg); 3512 apply(rhs, arg);
3864 return null; 3513 return null;
3865 } 3514 }
3866 3515
3867 @override 3516 @override
3868 R visitStaticGetterSetterCompound( 3517 R errorStaticFunctionSet(
3869 Send node, 3518 Send node,
3870 FunctionElement getter, 3519 MethodElement function,
3871 FunctionElement setter,
3872 AssignmentOperator operator,
3873 Node rhs, 3520 Node rhs,
3874 A arg) { 3521 A arg) {
3875 apply(rhs, arg); 3522 apply(rhs, arg);
3523 return null;
3524 }
3525
3526 @override
3527 R errorStaticGetterSet(
3528 SendSet node,
3529 FunctionElement getter,
3530 Node rhs,
3531 A arg) {
3532 apply(rhs, arg);
3876 return null; 3533 return null;
3877 } 3534 }
3878 3535
3879 @override 3536 @override
3880 R visitStaticGetterSetterPostfix( 3537 R errorStaticSetterGet(
3881 Send node, 3538 Send node,
3882 FunctionElement getter,
3883 FunctionElement setter, 3539 FunctionElement setter,
3884 IncDecOperator operator,
3885 A arg) { 3540 A arg) {
3886 return null; 3541 return null;
3887 } 3542 }
3888 3543
3889 @override 3544 @override
3890 R visitStaticGetterSetterPrefix( 3545 R errorStaticSetterInvoke(
3891 Send node, 3546 Send node,
3892 FunctionElement getter,
3893 FunctionElement setter, 3547 FunctionElement setter,
3894 IncDecOperator operator, 3548 NodeList arguments,
3549 CallStructure callStructure,
3895 A arg) { 3550 A arg) {
3551 apply(arguments, arg);
3896 return null; 3552 return null;
3897 } 3553 }
3898 3554
3899 @override 3555 @override
3900 R visitStaticMethodSetterCompound( 3556 R errorSuperGetterSet(
3901 Send node, 3557 SendSet node,
3902 FunctionElement method, 3558 FunctionElement getter,
3903 FunctionElement setter,
3904 AssignmentOperator operator,
3905 Node rhs, 3559 Node rhs,
3906 A arg) { 3560 A arg) {
3907 apply(rhs, arg); 3561 apply(rhs, arg);
3908 return null; 3562 return null;
3909 } 3563 }
3910 3564
3911 @override 3565 @override
3912 R visitStaticMethodSetterPostfix( 3566 R errorSuperMethodSet(
3913 Send node, 3567 Send node,
3914 FunctionElement getter, 3568 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, 3569 Node rhs,
3936 A arg) { 3570 A arg) {
3937 apply(rhs, arg); 3571 apply(rhs, arg);
3938 return null; 3572 return null;
3939 } 3573 }
3940 3574
3941 @override 3575 @override
3942 R visitSuperBinary( 3576 R errorSuperSetterGet(
3943 Send node, 3577 Send node,
3944 FunctionElement function, 3578 FunctionElement setter,
3945 BinaryOperator operator,
3946 Node argument,
3947 A arg) { 3579 A arg) {
3948 apply(argument, arg);
3949 return null; 3580 return null;
3950 } 3581 }
3951 3582
3952 @override 3583 @override
3953 R visitSuperCompoundIndexSet( 3584 R errorSuperSetterInvoke(
3954 SendSet node, 3585 Send node,
3955 FunctionElement getter,
3956 FunctionElement setter, 3586 FunctionElement setter,
3957 Node index, 3587 NodeList arguments,
3958 AssignmentOperator operator, 3588 CallStructure callStructure,
3589 A arg) {
3590 apply(arguments, arg);
3591 return null;
3592 }
3593
3594 @override
3595 R errorTopLevelFunctionSet(
3596 Send node,
3597 MethodElement function,
3959 Node rhs, 3598 Node rhs,
3960 A arg) { 3599 A arg) {
3961 apply(rhs, arg); 3600 apply(rhs, arg);
3601 return null;
3602 }
3603
3604 @override
3605 R errorTopLevelGetterSet(
3606 SendSet node,
3607 FunctionElement getter,
3608 Node rhs,
3609 A arg) {
3610 apply(rhs, arg);
3962 return null; 3611 return null;
3963 } 3612 }
3964 3613
3965 @override 3614 @override
3966 R visitSuperEquals( 3615 R errorTopLevelSetterGet(
3967 Send node, 3616 Send node,
3968 FunctionElement function, 3617 FunctionElement setter,
3969 Node argument,
3970 A arg) { 3618 A arg) {
3971 apply(argument, arg);
3972 return null; 3619 return null;
3973 } 3620 }
3974 3621
3975 @override 3622 @override
3976 R visitSuperFieldCompound( 3623 R errorTopLevelSetterInvoke(
3977 Send node, 3624 Send node,
3978 FieldElement field, 3625 FunctionElement setter,
3979 AssignmentOperator operator, 3626 NodeList arguments,
3627 CallStructure callStructure,
3628 A arg) {
3629 apply(arguments, arg);
3630 return null;
3631 }
3632
3633 @override
3634 R errorTypeVariableTypeLiteralSet(
3635 SendSet node,
3636 TypeVariableElement element,
3980 Node rhs, 3637 Node rhs,
3981 A arg) { 3638 A arg) {
3982 apply(rhs, arg); 3639 apply(rhs, arg);
3983 return null; 3640 return null;
3984 } 3641 }
3985 3642
3986 @override 3643 @override
3987 R visitSuperFieldFieldPostfix( 3644 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, 3645 SendSet node,
4046 FieldElement field, 3646 ConstantExpression constant,
4047 Node rhs, 3647 Node rhs,
4048 A arg) { 3648 A arg) {
4049 apply(rhs, arg); 3649 apply(rhs, arg);
4050 return null; 3650 return null;
4051 } 3651 }
4052 3652
4053 @override 3653 @override
4054 R visitSuperFieldSetterCompound( 3654 R visitUnresolvedSuperIndex(
4055 Send node, 3655 Send node,
4056 FieldElement field, 3656 Element function,
4057 FunctionElement setter, 3657 Node index,
3658 A arg) {
3659 apply(index, arg);
3660 return null;
3661 }
3662
3663 @override
3664 R visitUnresolvedSuperGet(
3665 Send node,
3666 Element element,
3667 A arg) {
3668 return null;
3669 }
3670
3671 @override
3672 R visitUnresolvedSuperInvoke(
3673 Send node,
3674 Element function,
3675 NodeList arguments,
3676 Selector selector,
3677 A arg) {
3678 apply(arguments, arg);
3679 return null;
3680 }
3681
3682 @override
3683 R visitAs(
3684 Send node,
3685 Node expression,
3686 DartType type,
3687 A arg) {
3688 apply(expression, arg);
3689 return null;
3690 }
3691
3692 @override
3693 R visitAssert(
3694 Send node,
3695 Node expression,
3696 A arg) {
3697 apply(expression, arg);
3698 return null;
3699 }
3700
3701 @override
3702 R visitBinary(
3703 Send node,
3704 Node left,
3705 BinaryOperator operator,
3706 Node right,
3707 A arg) {
3708 apply(left, arg);
3709 apply(right, arg);
3710 return null;
3711 }
3712
3713 @override
3714 R visitClassTypeLiteralCompound(
3715 Send node,
3716 ConstantExpression constant,
4058 AssignmentOperator operator, 3717 AssignmentOperator operator,
4059 Node rhs, 3718 Node rhs,
4060 A arg) { 3719 A arg) {
4061 apply(rhs, arg); 3720 apply(rhs, arg);
4062 return null; 3721 return null;
4063 } 3722 }
4064 3723
4065 @override 3724 @override
4066 R visitSuperFieldSetterPostfix( 3725 R visitClassTypeLiteralGet(
4067 Send node, 3726 Send node,
4068 FieldElement field, 3727 ConstantExpression constant,
4069 FunctionElement setter, 3728 A arg) {
3729 return null;
3730 }
3731
3732 @override
3733 R visitClassTypeLiteralInvoke(
3734 Send node,
3735 ConstantExpression constant,
3736 NodeList arguments,
3737 CallStructure callStructure,
3738 A arg) {
3739 apply(arguments, arg);
3740 return null;
3741 }
3742
3743 @override
3744 R visitClassTypeLiteralPostfix(
3745 Send node,
3746 ConstantExpression constant,
4070 IncDecOperator operator, 3747 IncDecOperator operator,
4071 A arg) { 3748 A arg) {
4072 return null; 3749 return null;
4073 } 3750 }
4074 3751
4075 @override 3752 @override
4076 R visitSuperFieldSetterPrefix( 3753 R visitClassTypeLiteralPrefix(
4077 Send node, 3754 Send node,
4078 FieldElement field, 3755 ConstantExpression constant,
4079 FunctionElement setter,
4080 IncDecOperator operator, 3756 IncDecOperator operator,
4081 A arg) { 3757 A arg) {
4082 return null; 3758 return null;
4083 } 3759 }
4084 3760
4085 @override 3761 @override
4086 R visitSuperGetterFieldCompound( 3762 R visitCompoundIndexSet(
4087 Send node, 3763 SendSet node,
4088 FunctionElement getter, 3764 Node receiver,
4089 FieldElement field, 3765 Node index,
4090 AssignmentOperator operator, 3766 AssignmentOperator operator,
4091 Node rhs, 3767 Node rhs,
4092 A arg) { 3768 A arg) {
3769 apply(receiver, arg);
3770 apply(index, arg);
4093 apply(rhs, arg); 3771 apply(rhs, arg);
4094 return null; 3772 return null;
4095 } 3773 }
4096 3774
4097 @override 3775 @override
4098 R visitSuperGetterFieldPostfix( 3776 R visitConstantGet(
4099 Send node, 3777 Send node,
4100 FunctionElement getter, 3778 ConstantExpression constant,
4101 FieldElement field,
4102 IncDecOperator operator,
4103 A arg) { 3779 A arg) {
4104 return null; 3780 return null;
4105 } 3781 }
4106 3782
4107 @override 3783 @override
4108 R visitSuperGetterFieldPrefix( 3784 R visitConstantInvoke(
4109 Send node, 3785 Send node,
4110 FunctionElement getter, 3786 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, 3787 NodeList arguments,
4130 CallStructure callStructure, 3788 CallStructure callStructure,
4131 A arg) { 3789 A arg) {
4132 apply(arguments, arg); 3790 apply(arguments, arg);
4133 return null; 3791 return null;
4134 } 3792 }
4135 3793
4136 @override 3794 @override
4137 R visitSuperGetterSetterCompound( 3795 R visitDynamicPropertyCompound(
4138 Send node, 3796 Send node,
4139 FunctionElement getter, 3797 Node receiver,
4140 FunctionElement setter, 3798 AssignmentOperator operator,
3799 Node rhs,
3800 Selector getterSelector,
3801 Selector setterSelector,
3802 A arg) {
3803 apply(receiver, arg);
3804 apply(rhs, arg);
3805 return null;
3806 }
3807
3808 @override
3809 R visitDynamicPropertyGet(
3810 Send node,
3811 Node receiver,
3812 Selector selector,
3813 A arg) {
3814 apply(receiver, arg);
3815 return null;
3816 }
3817
3818 @override
3819 R visitDynamicPropertyInvoke(
3820 Send node,
3821 Node receiver,
3822 NodeList arguments,
3823 Selector selector,
3824 A arg) {
3825 apply(receiver, arg);
3826 apply(arguments, arg);
3827 return null;
3828 }
3829
3830 @override
3831 R visitDynamicPropertyPostfix(
3832 Send node,
3833 Node receiver,
3834 IncDecOperator operator,
3835 Selector getterSelector,
3836 Selector setterSelector,
3837 A arg) {
3838 apply(receiver, arg);
3839 return null;
3840 }
3841
3842 @override
3843 R visitDynamicPropertyPrefix(
3844 Send node,
3845 Node receiver,
3846 IncDecOperator operator,
3847 Selector getterSelector,
3848 Selector setterSelector,
3849 A arg) {
3850 apply(receiver, arg);
3851 return null;
3852 }
3853
3854 @override
3855 R visitDynamicPropertySet(
3856 SendSet node,
3857 Node receiver,
3858 Selector selector,
3859 Node rhs,
3860 A arg) {
3861 apply(rhs, arg);
3862 return null;
3863 }
3864
3865 @override
3866 R visitDynamicTypeLiteralCompound(
3867 Send node,
3868 ConstantExpression constant,
4141 AssignmentOperator operator, 3869 AssignmentOperator operator,
4142 Node rhs, 3870 Node rhs,
4143 A arg) { 3871 A arg) {
4144 apply(rhs, arg); 3872 apply(rhs, arg);
4145 return null; 3873 return null;
4146 } 3874 }
4147 3875
4148 @override 3876 @override
4149 R visitSuperGetterSetterPostfix( 3877 R visitDynamicTypeLiteralGet(
4150 Send node, 3878 Send node,
4151 FunctionElement getter, 3879 ConstantExpression constant,
4152 FunctionElement setter,
4153 IncDecOperator operator,
4154 A arg) { 3880 A arg) {
4155 return null; 3881 return null;
4156 } 3882 }
4157 3883
4158 @override 3884 @override
4159 R visitSuperGetterSetterPrefix( 3885 R visitDynamicTypeLiteralInvoke(
4160 Send node, 3886 Send node,
4161 FunctionElement getter, 3887 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, 3888 NodeList arguments,
4203 CallStructure callStructure, 3889 CallStructure callStructure,
4204 A arg) { 3890 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); 3891 apply(arguments, arg);
4217 return null; 3892 return null;
4218 } 3893 }
4219 3894
4220 @override 3895 @override
4221 R visitSuperMethodSetterCompound( 3896 R visitDynamicTypeLiteralPostfix(
4222 Send node, 3897 Send node,
4223 FunctionElement method, 3898 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, 3899 IncDecOperator operator,
4238 A arg) { 3900 A arg) {
4239 return null; 3901 return null;
4240 } 3902 }
4241 3903
4242 @override 3904 @override
4243 R visitSuperMethodSetterPrefix( 3905 R visitDynamicTypeLiteralPrefix(
4244 Send node, 3906 Send node,
4245 FunctionElement method, 3907 ConstantExpression constant,
4246 FunctionElement setter,
4247 IncDecOperator operator, 3908 IncDecOperator operator,
4248 A arg) { 3909 A arg) {
4249 return null; 3910 return null;
4250 } 3911 }
4251 3912
4252 @override 3913 @override
4253 R visitSuperNotEquals( 3914 R visitEquals(
4254 Send node, 3915 Send node,
4255 FunctionElement function, 3916 Node left,
4256 Node argument, 3917 Node right,
4257 A arg) { 3918 A arg) {
4258 apply(argument, arg); 3919 apply(left, arg);
3920 apply(right, arg);
4259 return null; 3921 return null;
4260 } 3922 }
4261 3923
4262 @override 3924 @override
4263 R visitSuperSetterSet( 3925 R visitExpressionInvoke(
3926 Send node,
3927 Node expression,
3928 NodeList arguments,
3929 Selector selector,
3930 A arg) {
3931 apply(expression, arg);
3932 apply(arguments, arg);
3933 return null;
3934 }
3935
3936 @override
3937 R visitIndex(
3938 Send node,
3939 Node receiver,
3940 Node index,
3941 A arg) {
3942 apply(receiver, arg);
3943 apply(index, arg);
3944 return null;
3945 }
3946
3947 @override
3948 R visitIndexSet(
4264 SendSet node, 3949 SendSet node,
4265 FunctionElement setter, 3950 Node receiver,
3951 Node index,
4266 Node rhs, 3952 Node rhs,
4267 A arg) { 3953 A arg) {
3954 apply(receiver, arg);
3955 apply(index, arg);
4268 apply(rhs, arg); 3956 apply(rhs, arg);
4269 return null; 3957 return null;
4270 } 3958 }
4271 3959
4272 @override 3960 @override
4273 R visitSuperUnary( 3961 R visitIs(
4274 Send node, 3962 Send node,
4275 UnaryOperator operator, 3963 Node expression,
4276 FunctionElement function, 3964 DartType type,
3965 A arg) {
3966 apply(expression, arg);
3967 return null;
3968 }
3969
3970 @override
3971 R visitIsNot(
3972 Send node,
3973 Node expression,
3974 DartType type,
3975 A arg) {
3976 apply(expression, arg);
3977 return null;
3978 }
3979
3980 @override
3981 R visitLocalFunctionGet(
3982 Send node,
3983 LocalFunctionElement function,
4277 A arg) { 3984 A arg) {
4278 return null; 3985 return null;
4279 } 3986 }
4280 3987
4281 @override 3988 @override
4282 R visitThisGet(Identifier node, A arg) { 3989 R visitLocalFunctionInvoke(
4283 return null;
4284 }
4285
4286 @override
4287 R visitThisInvoke(
4288 Send node, 3990 Send node,
3991 LocalFunctionElement function,
4289 NodeList arguments, 3992 NodeList arguments,
4290 CallStructure callStructure, 3993 CallStructure callStructure,
4291 A arg) { 3994 A arg) {
4292 apply(arguments, arg); 3995 apply(arguments, arg);
4293 return null; 3996 return null;
4294 } 3997 }
4295 3998
4296 @override 3999 @override
4297 R visitThisPropertyCompound( 4000 R visitLocalVariableCompound(
4298 Send node, 4001 Send node,
4002 LocalVariableElement variable,
4299 AssignmentOperator operator, 4003 AssignmentOperator operator,
4300 Node rhs, 4004 Node rhs,
4301 Selector getterSelector,
4302 Selector setterSelector,
4303 A arg) { 4005 A arg) {
4304 apply(rhs, arg); 4006 apply(rhs, arg);
4305 return null; 4007 return null;
4306 } 4008 }
4307 4009
4308 @override 4010 @override
4309 R visitThisPropertyGet( 4011 R visitLocalVariableGet(
4310 Send node, 4012 Send node,
4311 Selector selector, 4013 LocalVariableElement variable,
4312 A arg) { 4014 A arg) {
4313 return null; 4015 return null;
4314 } 4016 }
4315 4017
4316 @override 4018 @override
4317 R visitThisPropertyInvoke( 4019 R visitLocalVariableInvoke(
4318 Send node, 4020 Send node,
4021 LocalVariableElement variable,
4319 NodeList arguments, 4022 NodeList arguments,
4320 Selector selector, 4023 CallStructure callStructure,
4321 A arg) { 4024 A arg) {
4322 apply(arguments, arg); 4025 apply(arguments, arg);
4323 return null; 4026 return null;
4324 } 4027 }
4325 4028
4326 @override 4029 @override
4327 R visitThisPropertyPostfix( 4030 R visitLocalVariablePostfix(
4328 Send node, 4031 Send node,
4032 LocalVariableElement variable,
4329 IncDecOperator operator, 4033 IncDecOperator operator,
4330 Selector getterSelector,
4331 Selector setterSelector,
4332 A arg) { 4034 A arg) {
4333 return null; 4035 return null;
4334 } 4036 }
4335 4037
4336 @override 4038 @override
4337 R visitThisPropertyPrefix( 4039 R visitLocalVariablePrefix(
4338 Send node, 4040 Send node,
4041 LocalVariableElement variable,
4339 IncDecOperator operator, 4042 IncDecOperator operator,
4340 Selector getterSelector,
4341 Selector setterSelector,
4342 A arg) { 4043 A arg) {
4343 return null; 4044 return null;
4344 } 4045 }
4345 4046
4346 @override 4047 @override
4347 R visitThisPropertySet( 4048 R visitLocalVariableSet(
4348 SendSet node, 4049 SendSet node,
4349 Selector selector, 4050 LocalVariableElement variable,
4350 Node rhs, 4051 Node rhs,
4351 A arg) { 4052 A arg) {
4352 apply(rhs, arg); 4053 apply(rhs, arg);
4353 return null; 4054 return null;
4354 } 4055 }
4355 4056
4356 @override 4057 @override
4357 R visitTopLevelFieldCompound( 4058 R visitLogicalAnd(
4059 Send node,
4060 Node left,
4061 Node right,
4062 A arg) {
4063 apply(left, arg);
4064 apply(right, arg);
4065 return null;
4066 }
4067
4068 @override
4069 R visitLogicalOr(
4070 Send node,
4071 Node left,
4072 Node right,
4073 A arg) {
4074 apply(left, arg);
4075 apply(right, arg);
4076 return null;
4077 }
4078
4079 @override
4080 R visitNot(
4081 Send node,
4082 Node expression,
4083 A arg) {
4084 apply(expression, arg);
4085 return null;
4086 }
4087
4088 @override
4089 R visitNotEquals(
4090 Send node,
4091 Node left,
4092 Node right,
4093 A arg) {
4094 apply(left, arg);
4095 apply(right, arg);
4096 return null;
4097 }
4098
4099 @override
4100 R visitParameterCompound(
4101 Send node,
4102 ParameterElement parameter,
4103 AssignmentOperator operator,
4104 Node rhs,
4105 A arg) {
4106 apply(rhs, arg);
4107 return null;
4108 }
4109
4110 @override
4111 R visitParameterGet(
4112 Send node,
4113 ParameterElement parameter,
4114 A arg) {
4115 return null;
4116 }
4117
4118 @override
4119 R visitParameterInvoke(
4120 Send node,
4121 ParameterElement parameter,
4122 NodeList arguments,
4123 CallStructure callStructure,
4124 A arg) {
4125 apply(arguments, arg);
4126 return null;
4127 }
4128
4129 @override
4130 R visitParameterPostfix(
4131 Send node,
4132 ParameterElement parameter,
4133 IncDecOperator operator,
4134 A arg) {
4135 return null;
4136 }
4137
4138 @override
4139 R visitParameterPrefix(
4140 Send node,
4141 ParameterElement parameter,
4142 IncDecOperator operator,
4143 A arg) {
4144 return null;
4145 }
4146
4147 @override
4148 R visitParameterSet(
4149 SendSet node,
4150 ParameterElement parameter,
4151 Node rhs,
4152 A arg) {
4153 apply(rhs, arg);
4154 return null;
4155 }
4156
4157 @override
4158 R visitStaticFieldCompound(
4358 Send node, 4159 Send node,
4359 FieldElement field, 4160 FieldElement field,
4360 AssignmentOperator operator, 4161 AssignmentOperator operator,
4361 Node rhs, 4162 Node rhs,
4362 A arg) { 4163 A arg) {
4363 apply(rhs, arg); 4164 apply(rhs, arg);
4364 return null; 4165 return null;
4365 } 4166 }
4366 4167
4367 @override 4168 @override
4368 R visitTopLevelFieldGet( 4169 R visitStaticFieldGet(
4369 Send node, 4170 Send node,
4370 FieldElement field, 4171 FieldElement field,
4371 A arg) { 4172 A arg) {
4372 return null; 4173 return null;
4373 } 4174 }
4374 4175
4375 @override 4176 @override
4376 R visitTopLevelFieldInvoke( 4177 R visitStaticFieldInvoke(
4377 Send node, 4178 Send node,
4378 FieldElement field, 4179 FieldElement field,
4379 NodeList arguments, 4180 NodeList arguments,
4380 CallStructure callStructure, 4181 CallStructure callStructure,
4381 A arg) { 4182 A arg) {
4382 apply(arguments, arg); 4183 apply(arguments, arg);
4383 return null; 4184 return null;
4384 } 4185 }
4385 4186
4386 @override 4187 @override
4387 R visitTopLevelFieldPostfix( 4188 R visitStaticFieldPostfix(
4388 Send node, 4189 Send node,
4389 FieldElement field, 4190 FieldElement field,
4390 IncDecOperator operator, 4191 IncDecOperator operator,
4391 A arg) { 4192 A arg) {
4392 return null; 4193 return null;
4393 } 4194 }
4394 4195
4395 @override 4196 @override
4396 R visitTopLevelFieldPrefix( 4197 R visitStaticFieldPrefix(
4397 Send node, 4198 Send node,
4398 FieldElement field, 4199 FieldElement field,
4399 IncDecOperator operator, 4200 IncDecOperator operator,
4400 A arg) { 4201 A arg) {
4401 return null; 4202 return null;
4402 } 4203 }
4403 4204
4404 @override 4205 @override
4405 R visitTopLevelFieldSet( 4206 R visitStaticFieldSet(
4406 SendSet node, 4207 SendSet node,
4407 FieldElement field, 4208 FieldElement field,
4408 Node rhs, 4209 Node rhs,
4409 A arg) { 4210 A arg) {
4410 apply(rhs, arg); 4211 apply(rhs, arg);
4411 return null; 4212 return null;
4412 } 4213 }
4413 4214
4414 @override 4215 @override
4415 R visitTopLevelFunctionGet( 4216 R visitStaticFunctionGet(
4416 Send node, 4217 Send node,
4417 MethodElement function, 4218 MethodElement function,
4418 A arg) { 4219 A arg) {
4419 return null; 4220 return null;
4420 } 4221 }
4421 4222
4422 @override 4223 @override
4423 R visitTopLevelFunctionInvoke( 4224 R visitStaticFunctionInvoke(
4424 Send node, 4225 Send node,
4425 MethodElement function, 4226 MethodElement function,
4426 NodeList arguments, 4227 NodeList arguments,
4427 CallStructure callStructure, 4228 CallStructure callStructure,
4428 A arg) { 4229 A arg) {
4429 apply(arguments, arg); 4230 apply(arguments, arg);
4430 return null; 4231 return null;
4431 } 4232 }
4432 4233
4433 @override 4234 @override
4434 R visitTopLevelFunctionIncompatibleInvoke( 4235 R visitStaticFunctionIncompatibleInvoke(
4435 Send node, 4236 Send node,
4436 MethodElement function, 4237 MethodElement function,
4437 NodeList arguments, 4238 NodeList arguments,
4438 CallStructure callStructure, 4239 CallStructure callStructure,
4439 A arg) { 4240 A arg) {
4440 apply(arguments, arg); 4241 apply(arguments, arg);
4441 return null; 4242 return null;
4442 } 4243 }
4443 4244
4444 @override 4245 @override
4445 R visitTopLevelGetterGet( 4246 R visitStaticGetterGet(
4446 Send node, 4247 Send node,
4447 FunctionElement getter, 4248 FunctionElement getter,
4448 A arg) { 4249 A arg) {
4449 return null; 4250 return null;
4450 } 4251 }
4451 4252
4452 @override 4253 @override
4453 R visitTopLevelGetterInvoke( 4254 R visitStaticGetterInvoke(
4454 Send node, 4255 Send node,
4455 FunctionElement getter, 4256 FunctionElement getter,
4456 NodeList arguments, 4257 NodeList arguments,
4457 CallStructure callStructure, 4258 CallStructure callStructure,
4458 A arg) { 4259 A arg) {
4459 apply(arguments, arg); 4260 apply(arguments, arg);
4460 return null; 4261 return null;
4461 } 4262 }
4462 4263
4463 @override 4264 @override
4464 R visitTopLevelGetterSetterCompound( 4265 R visitStaticGetterSetterCompound(
4465 Send node, 4266 Send node,
4466 FunctionElement getter, 4267 FunctionElement getter,
4467 FunctionElement setter, 4268 FunctionElement setter,
4468 AssignmentOperator operator, 4269 AssignmentOperator operator,
4469 Node rhs, 4270 Node rhs,
4470 A arg) { 4271 A arg) {
4471 apply(rhs, arg); 4272 apply(rhs, arg);
4472 return null; 4273 return null;
4473 } 4274 }
4474 4275
4475 @override 4276 @override
4476 R visitTopLevelGetterSetterPostfix( 4277 R visitStaticGetterSetterPostfix(
4477 Send node, 4278 Send node,
4478 FunctionElement getter, 4279 FunctionElement getter,
4479 FunctionElement setter, 4280 FunctionElement setter,
4480 IncDecOperator operator, 4281 IncDecOperator operator,
4481 A arg) { 4282 A arg) {
4482 return null; 4283 return null;
4483 } 4284 }
4484 4285
4485 @override 4286 @override
4486 R visitTopLevelGetterSetterPrefix( 4287 R visitStaticGetterSetterPrefix(
4487 Send node, 4288 Send node,
4488 FunctionElement getter, 4289 FunctionElement getter,
4489 FunctionElement setter, 4290 FunctionElement setter,
4490 IncDecOperator operator, 4291 IncDecOperator operator,
4491 A arg) { 4292 A arg) {
4492 return null; 4293 return null;
4493 } 4294 }
4494 4295
4495 @override 4296 @override
4496 R visitTopLevelMethodSetterCompound( 4297 R visitStaticMethodSetterCompound(
4497 Send node, 4298 Send node,
4498 FunctionElement method, 4299 FunctionElement method,
4499 FunctionElement setter, 4300 FunctionElement setter,
4500 AssignmentOperator operator, 4301 AssignmentOperator operator,
4501 Node rhs, 4302 Node rhs,
4502 A arg) { 4303 A arg) {
4503 apply(rhs, arg); 4304 apply(rhs, arg);
4504 return null; 4305 return null;
4505 } 4306 }
4506 4307
4507 @override 4308 @override
4508 R visitTopLevelMethodSetterPostfix( 4309 R visitStaticMethodSetterPostfix(
4509 Send node, 4310 Send node,
4510 FunctionElement method, 4311 FunctionElement getter,
4511 FunctionElement setter, 4312 FunctionElement setter,
4512 IncDecOperator operator, 4313 IncDecOperator operator,
4513 A arg) { 4314 A arg) {
4514 return null; 4315 return null;
4515 } 4316 }
4516 4317
4517 @override 4318 @override
4518 R visitTopLevelMethodSetterPrefix( 4319 R visitStaticMethodSetterPrefix(
4519 Send node, 4320 Send node,
4520 FunctionElement method, 4321 FunctionElement getter,
4521 FunctionElement setter, 4322 FunctionElement setter,
4522 IncDecOperator operator, 4323 IncDecOperator operator,
4523 A arg) { 4324 A arg) {
4524 return null; 4325 return null;
4525 } 4326 }
4526 4327
4527 @override 4328 @override
4528 R visitTopLevelSetterSet( 4329 R visitStaticSetterSet(
4529 SendSet node, 4330 SendSet node,
4530 FunctionElement setter, 4331 FunctionElement setter,
4531 Node rhs, 4332 Node rhs,
4532 A arg) { 4333 A arg) {
4533 apply(rhs, arg); 4334 apply(rhs, arg);
4534 return null; 4335 return null;
4535 } 4336 }
4536 4337
4537 @override 4338 @override
4538 R errorTypeVariableTypeLiteralCompound( 4339 R visitSuperBinary(
4539 Send node, 4340 Send node,
4540 TypeVariableElement element, 4341 FunctionElement function,
4342 BinaryOperator operator,
4343 Node argument,
4344 A arg) {
4345 apply(argument, arg);
4346 return null;
4347 }
4348
4349 @override
4350 R visitSuperCompoundIndexSet(
4351 SendSet node,
4352 FunctionElement getter,
4353 FunctionElement setter,
4354 Node index,
4541 AssignmentOperator operator, 4355 AssignmentOperator operator,
4542 Node rhs, 4356 Node rhs,
4543 A arg) { 4357 A arg) {
4544 apply(rhs, arg); 4358 apply(rhs, arg);
4545 return null; 4359 return null;
4546 } 4360 }
4547 4361
4548 @override 4362 @override
4549 R visitTypeVariableTypeLiteralGet( 4363 R visitSuperEquals(
4550 Send node, 4364 Send node,
4551 TypeVariableElement element, 4365 FunctionElement function,
4366 Node argument,
4552 A arg) { 4367 A arg) {
4368 apply(argument, arg);
4553 return null; 4369 return null;
4554 } 4370 }
4555 4371
4556 @override 4372 @override
4557 R visitTypeVariableTypeLiteralInvoke( 4373 R visitSuperFieldCompound(
4558 Send node, 4374 Send node,
4559 TypeVariableElement element, 4375 FieldElement field,
4560 NodeList arguments,
4561 CallStructure callStructure,
4562 A arg) {
4563 apply(arguments, arg);
4564 return null;
4565 }
4566
4567 @override
4568 R errorTypeVariableTypeLiteralPostfix(
4569 Send node,
4570 TypeVariableElement element,
4571 IncDecOperator operator,
4572 A arg) {
4573 return null;
4574 }
4575
4576 @override
4577 R errorTypeVariableTypeLiteralPrefix(
4578 Send node,
4579 TypeVariableElement element,
4580 IncDecOperator operator,
4581 A arg) {
4582 return null;
4583 }
4584
4585 @override
4586 R errorTypedefTypeLiteralCompound(
4587 Send node,
4588 ConstantExpression constant,
4589 AssignmentOperator operator, 4376 AssignmentOperator operator,
4590 Node rhs, 4377 Node rhs,
4591 A arg) { 4378 A arg) {
4592 apply(rhs, arg); 4379 apply(rhs, arg);
4593 return null; 4380 return null;
4594 } 4381 }
4595 4382
4596 @override 4383 @override
4597 R visitTypedefTypeLiteralGet( 4384 R visitSuperFieldFieldPostfix(
4598 Send node, 4385 Send node,
4599 ConstantExpression constant, 4386 FieldElement readField,
4387 FieldElement writtenField,
4388 IncDecOperator operator,
4600 A arg) { 4389 A arg) {
4601 return null; 4390 return null;
4602 } 4391 }
4603 4392
4604 @override 4393 @override
4605 R visitTypedefTypeLiteralInvoke( 4394 R visitSuperFieldFieldPrefix(
4606 Send node, 4395 Send node,
4607 ConstantExpression constant, 4396 FieldElement readField,
4397 FieldElement writtenField,
4398 IncDecOperator operator,
4399 A arg) {
4400 return null;
4401 }
4402
4403 @override
4404 R visitSuperFieldGet(
4405 Send node,
4406 FieldElement field,
4407 A arg) {
4408 return null;
4409 }
4410
4411 @override
4412 R visitSuperFieldInvoke(
4413 Send node,
4414 FieldElement field,
4608 NodeList arguments, 4415 NodeList arguments,
4609 CallStructure callStructure, 4416 CallStructure callStructure,
4610 A arg) { 4417 A arg) {
4611 apply(arguments, arg); 4418 apply(arguments, arg);
4612 return null; 4419 return null;
4613 } 4420 }
4614 4421
4615 @override 4422 @override
4616 R errorTypedefTypeLiteralPostfix( 4423 R visitSuperFieldPostfix(
4617 Send node, 4424 Send node,
4618 ConstantExpression constant, 4425 FieldElement field,
4619 IncDecOperator operator, 4426 IncDecOperator operator,
4620 A arg) { 4427 A arg) {
4621 return null; 4428 return null;
4622 } 4429 }
4623 4430
4624 @override 4431 @override
4625 R errorTypedefTypeLiteralPrefix( 4432 R visitSuperFieldPrefix(
4626 Send node, 4433 Send node,
4627 ConstantExpression constant, 4434 FieldElement field,
4628 IncDecOperator operator, 4435 IncDecOperator operator,
4629 A arg) { 4436 A arg) {
4630 return null; 4437 return null;
4631 } 4438 }
4632 4439
4633 @override 4440 @override
4634 R visitUnary( 4441 R visitSuperFieldSet(
4635 Send node, 4442 SendSet node,
4636 UnaryOperator operator, 4443 FieldElement field,
4637 Node expression, 4444 Node rhs,
4638 A arg) { 4445 A arg) {
4639 apply(expression, arg); 4446 apply(rhs, arg);
4640 return null; 4447 return null;
4641 } 4448 }
4642 4449
4643 @override 4450 @override
4644 R errorUnresolvedCompound( 4451 R visitSuperFieldSetterCompound(
4645 Send node, 4452 Send node,
4646 Element element, 4453 FieldElement field,
4454 FunctionElement setter,
4647 AssignmentOperator operator, 4455 AssignmentOperator operator,
4648 Node rhs, 4456 Node rhs,
4649 A arg) { 4457 A arg) {
4650 apply(rhs, arg); 4458 apply(rhs, arg);
4651 return null; 4459 return null;
4652 } 4460 }
4653 4461
4654 @override 4462 @override
4655 R visitUnresolvedGet( 4463 R visitSuperFieldSetterPostfix(
4656 Send node, 4464 Send node,
4657 Element element, 4465 FieldElement field,
4658 A arg) { 4466 FunctionElement setter,
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, 4467 IncDecOperator operator,
4678 A arg) { 4468 A arg) {
4679 return null; 4469 return null;
4680 } 4470 }
4681 4471
4682 @override 4472 @override
4683 R errorUnresolvedPrefix( 4473 R visitSuperFieldSetterPrefix(
4684 Send node, 4474 Send node,
4685 Element element, 4475 FieldElement field,
4476 FunctionElement setter,
4686 IncDecOperator operator, 4477 IncDecOperator operator,
4687 A arg) { 4478 A arg) {
4688 return null; 4479 return null;
4689 } 4480 }
4690 4481
4691 @override 4482 @override
4692 R errorUnresolvedSet( 4483 R visitSuperGetterFieldCompound(
4693 Send node, 4484 Send node,
4694 Element element, 4485 FunctionElement getter,
4486 FieldElement field,
4487 AssignmentOperator operator,
4695 Node rhs, 4488 Node rhs,
4696 A arg) { 4489 A arg) {
4697 apply(rhs, arg); 4490 apply(rhs, arg);
4698 return null; 4491 return null;
4699 } 4492 }
4700 4493
4701 @override 4494 @override
4702 R errorUndefinedBinaryExpression( 4495 R visitSuperGetterFieldPostfix(
4703 Send node, 4496 Send node,
4704 Node left, 4497 FunctionElement getter,
4705 Operator operator, 4498 FieldElement field,
4706 Node right, 4499 IncDecOperator operator,
4707 A arg) { 4500 A arg) {
4708 apply(left, arg);
4709 apply(right, arg);
4710 return null; 4501 return null;
4711 } 4502 }
4712 4503
4713 @override 4504 @override
4714 R errorUndefinedUnaryExpression( 4505 R visitSuperGetterFieldPrefix(
4715 Send node, 4506 Send node,
4716 Operator operator, 4507 FunctionElement getter,
4717 Node expression, 4508 FieldElement field,
4509 IncDecOperator operator,
4718 A arg) { 4510 A arg) {
4719 apply(expression, arg);
4720 return null; 4511 return null;
4721 } 4512 }
4722 4513
4723 @override 4514 @override
4724 R visitUnresolvedSuperIndexSet( 4515 R visitSuperGetterGet(
4725 Send node, 4516 Send node,
4726 Element element, 4517 FunctionElement getter,
4727 Node index, 4518 A arg) {
4519 return null;
4520 }
4521
4522 @override
4523 R visitSuperGetterInvoke(
4524 Send node,
4525 FunctionElement getter,
4526 NodeList arguments,
4527 CallStructure callStructure,
4528 A arg) {
4529 apply(arguments, arg);
4530 return null;
4531 }
4532
4533 @override
4534 R visitSuperGetterSetterCompound(
4535 Send node,
4536 FunctionElement getter,
4537 FunctionElement setter,
4538 AssignmentOperator operator,
4728 Node rhs, 4539 Node rhs,
4729 A arg) { 4540 A arg) {
4730 apply(index, arg);
4731 apply(rhs, arg); 4541 apply(rhs, arg);
4732 return null; 4542 return null;
4733 } 4543 }
4734 4544
4735 @override 4545 @override
4736 R visitUnresolvedSuperGetterCompoundIndexSet( 4546 R visitSuperGetterSetterPostfix(
4737 SendSet node, 4547 Send node,
4738 Element element, 4548 FunctionElement getter,
4739 Node index, 4549 FunctionElement setter,
4740 AssignmentOperator operator, 4550 IncDecOperator operator,
4741 Node rhs,
4742 A arg) { 4551 A arg) {
4743 apply(index, arg);
4744 apply(rhs, arg);
4745 return null; 4552 return null;
4746 } 4553 }
4747 4554
4748 @override 4555 @override
4749 R visitUnresolvedSuperSetterCompoundIndexSet( 4556 R visitSuperGetterSetterPrefix(
4557 Send node,
4558 FunctionElement getter,
4559 FunctionElement setter,
4560 IncDecOperator operator,
4561 A arg) {
4562 return null;
4563 }
4564
4565 @override
4566 R visitSuperIndex(
4567 Send node,
4568 FunctionElement function,
4569 Node index,
4570 A arg) {
4571 apply(index, arg);
4572 return null;
4573 }
4574
4575 @override
4576 R visitSuperIndexSet(
4750 SendSet node, 4577 SendSet node,
4751 MethodElement getter, 4578 FunctionElement function,
4752 Element element,
4753 Node index, 4579 Node index,
4754 AssignmentOperator operator,
4755 Node rhs, 4580 Node rhs,
4756 A arg) { 4581 A arg) {
4757 apply(index, arg); 4582 apply(index, arg);
4758 apply(rhs, arg); 4583 apply(rhs, arg);
4759 return null; 4584 return null;
4760 } 4585 }
4761 4586
4762 @override 4587 @override
4763 R visitUnresolvedSuperBinary( 4588 R visitSuperMethodGet(
4764 Send node, 4589 Send node,
4765 Element element, 4590 MethodElement method,
4766 BinaryOperator operator, 4591 A arg) {
4592 return null;
4593 }
4594
4595 @override
4596 R visitSuperMethodInvoke(
4597 Send node,
4598 MethodElement method,
4599 NodeList arguments,
4600 CallStructure callStructure,
4601 A arg) {
4602 apply(arguments, arg);
4603 return null;
4604 }
4605
4606 @override
4607 R visitSuperMethodIncompatibleInvoke(
4608 Send node,
4609 MethodElement method,
4610 NodeList arguments,
4611 CallStructure callStructure,
4612 A arg) {
4613 apply(arguments, arg);
4614 return null;
4615 }
4616
4617 @override
4618 R visitSuperMethodSetterCompound(
4619 Send node,
4620 FunctionElement method,
4621 FunctionElement setter,
4622 AssignmentOperator operator,
4623 Node rhs,
4624 A arg) {
4625 apply(rhs, arg);
4626 return null;
4627 }
4628
4629 @override
4630 R visitSuperMethodSetterPostfix(
4631 Send node,
4632 FunctionElement method,
4633 FunctionElement setter,
4634 IncDecOperator operator,
4635 A arg) {
4636 return null;
4637 }
4638
4639 @override
4640 R visitSuperMethodSetterPrefix(
4641 Send node,
4642 FunctionElement method,
4643 FunctionElement setter,
4644 IncDecOperator operator,
4645 A arg) {
4646 return null;
4647 }
4648
4649 @override
4650 R visitSuperNotEquals(
4651 Send node,
4652 FunctionElement function,
4767 Node argument, 4653 Node argument,
4768 A arg) { 4654 A arg) {
4769 apply(argument, arg); 4655 apply(argument, arg);
4770 return null; 4656 return null;
4771 } 4657 }
4772 4658
4773 @override 4659 @override
4774 R visitUnresolvedSuperUnary( 4660 R visitSuperSetterSet(
4661 SendSet node,
4662 FunctionElement setter,
4663 Node rhs,
4664 A arg) {
4665 apply(rhs, arg);
4666 return null;
4667 }
4668
4669 @override
4670 R visitSuperUnary(
4775 Send node, 4671 Send node,
4776 UnaryOperator operator, 4672 UnaryOperator operator,
4777 Element element, 4673 FunctionElement function,
4778 A arg) { 4674 A arg) {
4779 return null; 4675 return null;
4780 } 4676 }
4781 4677
4782 @override 4678 @override
4783 R visitUnresolvedSuperGetterIndexPostfix( 4679 R visitThisGet(Identifier node, A arg) {
4784 Send node,
4785 Element element,
4786 Node index,
4787 IncDecOperator operator,
4788 A arg) {
4789 apply(index, arg);
4790 return null; 4680 return null;
4791 } 4681 }
4792 4682
4793 @override 4683 @override
4794 R visitUnresolvedSuperSetterIndexPostfix( 4684 R visitThisInvoke(
4795 Send node, 4685 Send node,
4796 MethodElement getter,
4797 Element element,
4798 Node index,
4799 IncDecOperator operator,
4800 A arg) {
4801 apply(index, arg);
4802 return null;
4803 }
4804
4805 @override
4806 R visitUnresolvedSuperGetterIndexPrefix(
4807 Send node,
4808 Element element,
4809 Node index,
4810 IncDecOperator operator,
4811 A arg) {
4812 apply(index, arg);
4813 return null;
4814 }
4815
4816 @override
4817 R visitUnresolvedSuperSetterIndexPrefix(
4818 Send node,
4819 MethodElement getter,
4820 Element element,
4821 Node index,
4822 IncDecOperator operator,
4823 A arg) {
4824 apply(index, arg);
4825 return null;
4826 }
4827
4828 @override
4829 R visitIndexPostfix(
4830 Send node,
4831 Node receiver,
4832 Node index,
4833 IncDecOperator operator,
4834 A arg) {
4835 apply(receiver, arg);
4836 apply(index, arg);
4837 return null;
4838 }
4839
4840 @override
4841 R visitIndexPrefix(
4842 Send node,
4843 Node receiver,
4844 Node index,
4845 IncDecOperator operator,
4846 A arg) {
4847 apply(receiver, arg);
4848 apply(index, arg);
4849 return null;
4850 }
4851
4852 @override
4853 R visitSuperIndexPostfix(
4854 Send node,
4855 FunctionElement indexFunction,
4856 FunctionElement indexSetFunction,
4857 Node index,
4858 IncDecOperator operator,
4859 A arg) {
4860 apply(index, arg);
4861 return null;
4862 }
4863
4864 @override
4865 R visitSuperIndexPrefix(
4866 Send node,
4867 FunctionElement indexFunction,
4868 FunctionElement indexSetFunction,
4869 Node index,
4870 IncDecOperator operator,
4871 A arg) {
4872 apply(index, arg);
4873 return null;
4874 }
4875
4876 R visitConstConstructorInvoke(
4877 NewExpression node,
4878 ConstructedConstantExpression constant,
4879 A arg) {
4880 return null;
4881 }
4882
4883 @override
4884 R visitUnresolvedClassConstructorInvoke(
4885 NewExpression node,
4886 Element constructor,
4887 DartType type,
4888 NodeList arguments, 4686 NodeList arguments,
4889 Selector selector, 4687 CallStructure callStructure,
4890 A arg) { 4688 A arg) {
4891 apply(arguments, arg); 4689 apply(arguments, arg);
4892 return null; 4690 return null;
4893 } 4691 }
4894 4692
4895 @override 4693 @override
4896 R visitUnresolvedConstructorInvoke( 4694 R visitThisPropertyCompound(
4897 NewExpression node, 4695 Send node,
4898 Element constructor, 4696 AssignmentOperator operator,
4899 DartType type, 4697 Node rhs,
4698 Selector getterSelector,
4699 Selector setterSelector,
4700 A arg) {
4701 apply(rhs, arg);
4702 return null;
4703 }
4704
4705 @override
4706 R visitThisPropertyGet(
4707 Send node,
4708 Selector selector,
4709 A arg) {
4710 return null;
4711 }
4712
4713 @override
4714 R visitThisPropertyInvoke(
4715 Send node,
4900 NodeList arguments, 4716 NodeList arguments,
4901 Selector selector, 4717 Selector selector,
4902 A arg) { 4718 A arg) {
4903 apply(arguments, arg); 4719 apply(arguments, arg);
4904 return null; 4720 return null;
4905 } 4721 }
4906 4722
4907 @override 4723 @override
4908 R visitFactoryConstructorInvoke( 4724 R visitThisPropertyPostfix(
4909 NewExpression node, 4725 Send node,
4910 ConstructorElement constructor, 4726 IncDecOperator operator,
4911 InterfaceType type, 4727 Selector getterSelector,
4912 NodeList arguments, 4728 Selector setterSelector,
4913 CallStructure callStructure,
4914 A arg) { 4729 A arg) {
4915 apply(arguments, arg);
4916 return null; 4730 return null;
4917 } 4731 }
4918 4732
4919 @override 4733 @override
4920 R visitGenerativeConstructorInvoke( 4734 R visitThisPropertyPrefix(
4921 NewExpression node, 4735 Send node,
4922 ConstructorElement constructor, 4736 IncDecOperator operator,
4923 InterfaceType type, 4737 Selector getterSelector,
4924 NodeList arguments, 4738 Selector setterSelector,
4925 CallStructure callStructure,
4926 A arg) { 4739 A arg) {
4927 apply(arguments, arg);
4928 return null; 4740 return null;
4929 } 4741 }
4930 4742
4931 @override 4743 @override
4932 R visitRedirectingFactoryConstructorInvoke( 4744 R visitThisPropertySet(
4933 NewExpression node, 4745 SendSet node,
4934 ConstructorElement constructor, 4746 Selector selector,
4935 InterfaceType type, 4747 Node rhs,
4936 ConstructorElement effectiveTarget,
4937 InterfaceType effectiveTargetType,
4938 NodeList arguments,
4939 CallStructure callStructure,
4940 A arg) { 4748 A arg) {
4941 apply(arguments, arg); 4749 apply(rhs, arg);
4942 return null; 4750 return null;
4943 } 4751 }
4944 4752
4945 @override 4753 @override
4946 R visitRedirectingGenerativeConstructorInvoke( 4754 R visitTopLevelFieldCompound(
4947 NewExpression node, 4755 Send node,
4948 ConstructorElement constructor, 4756 FieldElement field,
4949 InterfaceType type, 4757 AssignmentOperator operator,
4950 NodeList arguments, 4758 Node rhs,
4951 CallStructure callStructure,
4952 A arg) { 4759 A arg) {
4953 apply(arguments, arg); 4760 apply(rhs, arg);
4954 return null; 4761 return null;
4955 } 4762 }
4956 4763
4957 @override 4764 @override
4958 R visitAbstractClassConstructorInvoke( 4765 R visitTopLevelFieldGet(
4959 NewExpression node, 4766 Send node,
4960 ConstructorElement element, 4767 FieldElement field,
4961 InterfaceType type,
4962 NodeList arguments,
4963 CallStructure callStructure,
4964 A arg) { 4768 A arg) {
4965 apply(arguments, arg);
4966 return null; 4769 return null;
4967 } 4770 }
4968 4771
4969 @override 4772 @override
4970 R visitUnresolvedRedirectingFactoryConstructorInvoke( 4773 R visitTopLevelFieldInvoke(
4971 NewExpression node, 4774 Send node,
4972 ConstructorElement constructor, 4775 FieldElement field,
4973 InterfaceType type,
4974 NodeList arguments, 4776 NodeList arguments,
4975 CallStructure callStructure, 4777 CallStructure callStructure,
4976 A arg) { 4778 A arg) {
4977 apply(arguments, arg); 4779 apply(arguments, arg);
4978 return null; 4780 return null;
4979 } 4781 }
4980 4782
4981 @override 4783 @override
4784 R visitTopLevelFieldPostfix(
4785 Send node,
4786 FieldElement field,
4787 IncDecOperator operator,
4788 A arg) {
4789 return null;
4790 }
4791
4792 @override
4793 R visitTopLevelFieldPrefix(
4794 Send node,
4795 FieldElement field,
4796 IncDecOperator operator,
4797 A arg) {
4798 return null;
4799 }
4800
4801 @override
4802 R visitTopLevelFieldSet(
4803 SendSet node,
4804 FieldElement field,
4805 Node rhs,
4806 A arg) {
4807 apply(rhs, arg);
4808 return null;
4809 }
4810
4811 @override
4812 R visitTopLevelFunctionGet(
4813 Send node,
4814 MethodElement function,
4815 A arg) {
4816 return null;
4817 }
4818
4819 @override
4820 R visitTopLevelFunctionInvoke(
4821 Send node,
4822 MethodElement function,
4823 NodeList arguments,
4824 CallStructure callStructure,
4825 A arg) {
4826 apply(arguments, arg);
4827 return null;
4828 }
4829
4830 @override
4831 R visitTopLevelFunctionIncompatibleInvoke(
4832 Send node,
4833 MethodElement function,
4834 NodeList arguments,
4835 CallStructure callStructure,
4836 A arg) {
4837 apply(arguments, arg);
4838 return null;
4839 }
4840
4841 @override
4842 R visitTopLevelGetterGet(
4843 Send node,
4844 FunctionElement getter,
4845 A arg) {
4846 return null;
4847 }
4848
4849 @override
4850 R visitTopLevelGetterInvoke(
4851 Send node,
4852 FunctionElement getter,
4853 NodeList arguments,
4854 CallStructure callStructure,
4855 A arg) {
4856 apply(arguments, arg);
4857 return null;
4858 }
4859
4860 @override
4861 R visitTopLevelGetterSetterCompound(
4862 Send node,
4863 FunctionElement getter,
4864 FunctionElement setter,
4865 AssignmentOperator operator,
4866 Node rhs,
4867 A arg) {
4868 apply(rhs, arg);
4869 return null;
4870 }
4871
4872 @override
4873 R visitTopLevelGetterSetterPostfix(
4874 Send node,
4875 FunctionElement getter,
4876 FunctionElement setter,
4877 IncDecOperator operator,
4878 A arg) {
4879 return null;
4880 }
4881
4882 @override
4883 R visitTopLevelGetterSetterPrefix(
4884 Send node,
4885 FunctionElement getter,
4886 FunctionElement setter,
4887 IncDecOperator operator,
4888 A arg) {
4889 return null;
4890 }
4891
4892 @override
4893 R visitTopLevelMethodSetterCompound(
4894 Send node,
4895 FunctionElement method,
4896 FunctionElement setter,
4897 AssignmentOperator operator,
4898 Node rhs,
4899 A arg) {
4900 apply(rhs, arg);
4901 return null;
4902 }
4903
4904 @override
4905 R visitTopLevelMethodSetterPostfix(
4906 Send node,
4907 FunctionElement method,
4908 FunctionElement setter,
4909 IncDecOperator operator,
4910 A arg) {
4911 return null;
4912 }
4913
4914 @override
4915 R visitTopLevelMethodSetterPrefix(
4916 Send node,
4917 FunctionElement method,
4918 FunctionElement setter,
4919 IncDecOperator operator,
4920 A arg) {
4921 return null;
4922 }
4923
4924 @override
4925 R visitTopLevelSetterSet(
4926 SendSet node,
4927 FunctionElement setter,
4928 Node rhs,
4929 A arg) {
4930 apply(rhs, arg);
4931 return null;
4932 }
4933
4934 @override
4935 R visitTypeVariableTypeLiteralCompound(
4936 Send node,
4937 TypeVariableElement element,
4938 AssignmentOperator operator,
4939 Node rhs,
4940 A arg) {
4941 apply(rhs, arg);
4942 return null;
4943 }
4944
4945 @override
4946 R visitTypeVariableTypeLiteralGet(
4947 Send node,
4948 TypeVariableElement element,
4949 A arg) {
4950 return null;
4951 }
4952
4953 @override
4954 R visitTypeVariableTypeLiteralInvoke(
4955 Send node,
4956 TypeVariableElement element,
4957 NodeList arguments,
4958 CallStructure callStructure,
4959 A arg) {
4960 apply(arguments, arg);
4961 return null;
4962 }
4963
4964 @override
4965 R visitTypeVariableTypeLiteralPostfix(
4966 Send node,
4967 TypeVariableElement element,
4968 IncDecOperator operator,
4969 A arg) {
4970 return null;
4971 }
4972
4973 @override
4974 R visitTypeVariableTypeLiteralPrefix(
4975 Send node,
4976 TypeVariableElement element,
4977 IncDecOperator operator,
4978 A arg) {
4979 return null;
4980 }
4981
4982 @override
4983 R visitTypedefTypeLiteralCompound(
4984 Send node,
4985 ConstantExpression constant,
4986 AssignmentOperator operator,
4987 Node rhs,
4988 A arg) {
4989 apply(rhs, arg);
4990 return null;
4991 }
4992
4993 @override
4994 R visitTypedefTypeLiteralGet(
4995 Send node,
4996 ConstantExpression constant,
4997 A arg) {
4998 return null;
4999 }
5000
5001 @override
5002 R visitTypedefTypeLiteralInvoke(
5003 Send node,
5004 ConstantExpression constant,
5005 NodeList arguments,
5006 CallStructure callStructure,
5007 A arg) {
5008 apply(arguments, arg);
5009 return null;
5010 }
5011
5012 @override
5013 R visitTypedefTypeLiteralPostfix(
5014 Send node,
5015 ConstantExpression constant,
5016 IncDecOperator operator,
5017 A arg) {
5018 return null;
5019 }
5020
5021 @override
5022 R visitTypedefTypeLiteralPrefix(
5023 Send node,
5024 ConstantExpression constant,
5025 IncDecOperator operator,
5026 A arg) {
5027 return null;
5028 }
5029
5030 @override
5031 R visitUnary(
5032 Send node,
5033 UnaryOperator operator,
5034 Node expression,
5035 A arg) {
5036 apply(expression, arg);
5037 return null;
5038 }
5039
5040 @override
5041 R visitUnresolvedCompound(
5042 Send node,
5043 Element element,
5044 AssignmentOperator operator,
5045 Node rhs,
5046 A arg) {
5047 apply(rhs, arg);
5048 return null;
5049 }
5050
5051 @override
5052 R visitUnresolvedGet(
5053 Send node,
5054 Element element,
5055 A arg) {
5056 return null;
5057 }
5058
5059 @override
5060 R visitUnresolvedInvoke(
5061 Send node,
5062 Element element,
5063 NodeList arguments,
5064 Selector selector,
5065 A arg) {
5066 apply(arguments, arg);
5067 return null;
5068 }
5069
5070 @override
5071 R visitUnresolvedPostfix(
5072 Send node,
5073 Element element,
5074 IncDecOperator operator,
5075 A arg) {
5076 return null;
5077 }
5078
5079 @override
5080 R visitUnresolvedPrefix(
5081 Send node,
5082 Element element,
5083 IncDecOperator operator,
5084 A arg) {
5085 return null;
5086 }
5087
5088 @override
5089 R errorUnresolvedSet(
5090 Send node,
5091 Element element,
5092 Node rhs,
5093 A arg) {
5094 apply(rhs, arg);
5095 return null;
5096 }
5097
5098 @override
5099 R errorUndefinedBinaryExpression(
5100 Send node,
5101 Node left,
5102 Operator operator,
5103 Node right,
5104 A arg) {
5105 apply(left, arg);
5106 apply(right, arg);
5107 return null;
5108 }
5109
5110 @override
5111 R errorUndefinedUnaryExpression(
5112 Send node,
5113 Operator operator,
5114 Node expression,
5115 A arg) {
5116 apply(expression, arg);
5117 return null;
5118 }
5119
5120 @override
5121 R visitUnresolvedSuperIndexSet(
5122 Send node,
5123 Element element,
5124 Node index,
5125 Node rhs,
5126 A arg) {
5127 apply(index, arg);
5128 apply(rhs, arg);
5129 return null;
5130 }
5131
5132 @override
5133 R visitUnresolvedSuperGetterCompoundIndexSet(
5134 SendSet node,
5135 Element element,
5136 Node index,
5137 AssignmentOperator operator,
5138 Node rhs,
5139 A arg) {
5140 apply(index, arg);
5141 apply(rhs, arg);
5142 return null;
5143 }
5144
5145 @override
5146 R visitUnresolvedSuperSetterCompoundIndexSet(
5147 SendSet node,
5148 MethodElement getter,
5149 Element element,
5150 Node index,
5151 AssignmentOperator operator,
5152 Node rhs,
5153 A arg) {
5154 apply(index, arg);
5155 apply(rhs, arg);
5156 return null;
5157 }
5158
5159 @override
5160 R visitUnresolvedSuperBinary(
5161 Send node,
5162 Element element,
5163 BinaryOperator operator,
5164 Node argument,
5165 A arg) {
5166 apply(argument, arg);
5167 return null;
5168 }
5169
5170 @override
5171 R visitUnresolvedSuperUnary(
5172 Send node,
5173 UnaryOperator operator,
5174 Element element,
5175 A arg) {
5176 return null;
5177 }
5178
5179 @override
5180 R visitUnresolvedSuperGetterIndexPostfix(
5181 Send node,
5182 Element element,
5183 Node index,
5184 IncDecOperator operator,
5185 A arg) {
5186 apply(index, arg);
5187 return null;
5188 }
5189
5190 @override
5191 R visitUnresolvedSuperSetterIndexPostfix(
5192 Send node,
5193 MethodElement getter,
5194 Element element,
5195 Node index,
5196 IncDecOperator operator,
5197 A arg) {
5198 apply(index, arg);
5199 return null;
5200 }
5201
5202 @override
5203 R visitUnresolvedSuperGetterIndexPrefix(
5204 Send node,
5205 Element element,
5206 Node index,
5207 IncDecOperator operator,
5208 A arg) {
5209 apply(index, arg);
5210 return null;
5211 }
5212
5213 @override
5214 R visitUnresolvedSuperSetterIndexPrefix(
5215 Send node,
5216 MethodElement getter,
5217 Element element,
5218 Node index,
5219 IncDecOperator operator,
5220 A arg) {
5221 apply(index, arg);
5222 return null;
5223 }
5224
5225 @override
5226 R visitIndexPostfix(
5227 Send node,
5228 Node receiver,
5229 Node index,
5230 IncDecOperator operator,
5231 A arg) {
5232 apply(receiver, arg);
5233 apply(index, arg);
5234 return null;
5235 }
5236
5237 @override
5238 R visitIndexPrefix(
5239 Send node,
5240 Node receiver,
5241 Node index,
5242 IncDecOperator operator,
5243 A arg) {
5244 apply(receiver, arg);
5245 apply(index, arg);
5246 return null;
5247 }
5248
5249 @override
5250 R visitSuperIndexPostfix(
5251 Send node,
5252 FunctionElement indexFunction,
5253 FunctionElement indexSetFunction,
5254 Node index,
5255 IncDecOperator operator,
5256 A arg) {
5257 apply(index, arg);
5258 return null;
5259 }
5260
5261 @override
5262 R visitSuperIndexPrefix(
5263 Send node,
5264 FunctionElement indexFunction,
5265 FunctionElement indexSetFunction,
5266 Node index,
5267 IncDecOperator operator,
5268 A arg) {
5269 apply(index, arg);
5270 return null;
5271 }
5272
5273 @override
5274 R visitConstConstructorInvoke(
5275 NewExpression node,
5276 ConstructedConstantExpression constant,
5277 A arg) {
5278 return null;
5279 }
5280
5281 @override
5282 R visitUnresolvedClassConstructorInvoke(
5283 NewExpression node,
5284 Element constructor,
5285 DartType type,
5286 NodeList arguments,
5287 Selector selector,
5288 A arg) {
5289 apply(arguments, arg);
5290 return null;
5291 }
5292
5293 @override
5294 R visitUnresolvedConstructorInvoke(
5295 NewExpression node,
5296 Element constructor,
5297 DartType type,
5298 NodeList arguments,
5299 Selector selector,
5300 A arg) {
5301 apply(arguments, arg);
5302 return null;
5303 }
5304
5305 @override
5306 R visitFactoryConstructorInvoke(
5307 NewExpression node,
5308 ConstructorElement constructor,
5309 InterfaceType type,
5310 NodeList arguments,
5311 CallStructure callStructure,
5312 A arg) {
5313 apply(arguments, arg);
5314 return null;
5315 }
5316
5317 @override
5318 R visitGenerativeConstructorInvoke(
5319 NewExpression node,
5320 ConstructorElement constructor,
5321 InterfaceType type,
5322 NodeList arguments,
5323 CallStructure callStructure,
5324 A arg) {
5325 apply(arguments, arg);
5326 return null;
5327 }
5328
5329 @override
5330 R visitRedirectingFactoryConstructorInvoke(
5331 NewExpression node,
5332 ConstructorElement constructor,
5333 InterfaceType type,
5334 ConstructorElement effectiveTarget,
5335 InterfaceType effectiveTargetType,
5336 NodeList arguments,
5337 CallStructure callStructure,
5338 A arg) {
5339 apply(arguments, arg);
5340 return null;
5341 }
5342
5343 @override
5344 R visitRedirectingGenerativeConstructorInvoke(
5345 NewExpression node,
5346 ConstructorElement constructor,
5347 InterfaceType type,
5348 NodeList arguments,
5349 CallStructure callStructure,
5350 A arg) {
5351 apply(arguments, arg);
5352 return null;
5353 }
5354
5355 @override
5356 R visitAbstractClassConstructorInvoke(
5357 NewExpression node,
5358 ConstructorElement element,
5359 InterfaceType type,
5360 NodeList arguments,
5361 CallStructure callStructure,
5362 A arg) {
5363 apply(arguments, arg);
5364 return null;
5365 }
5366
5367 @override
5368 R visitUnresolvedRedirectingFactoryConstructorInvoke(
5369 NewExpression node,
5370 ConstructorElement constructor,
5371 InterfaceType type,
5372 NodeList arguments,
5373 CallStructure callStructure,
5374 A arg) {
5375 apply(arguments, arg);
5376 return null;
5377 }
5378
5379 @override
4982 R errorNonConstantConstructorInvoke( 5380 R errorNonConstantConstructorInvoke(
4983 NewExpression node, 5381 NewExpression node,
4984 Element element, 5382 Element element,
4985 InterfaceType type, 5383 InterfaceType type,
4986 NodeList arguments, 5384 NodeList arguments,
4987 CallStructure callStructure, 5385 CallStructure callStructure,
4988 A arg) { 5386 A arg) {
4989 apply(arguments, arg); 5387 apply(arguments, arg);
4990 return null; 5388 return null;
4991 } 5389 }
5390
5391 @override
5392 R visitUnresolvedStaticGetterCompound(
5393 Send node,
5394 Element element,
5395 MethodElement setter,
5396 AssignmentOperator operator,
5397 Node rhs,
5398 A arg) {
5399 apply(rhs, arg);
5400 return null;
5401 }
5402
5403 @override
5404 R visitUnresolvedTopLevelGetterCompound(
5405 Send node,
5406 Element element,
5407 MethodElement setter,
5408 AssignmentOperator operator,
5409 Node rhs,
5410 A arg) {
5411 apply(rhs, arg);
5412 return null;
5413 }
5414
5415 @override
5416 R visitUnresolvedStaticSetterCompound(
5417 Send node,
5418 MethodElement getter,
5419 Element element,
5420 AssignmentOperator operator,
5421 Node rhs,
5422 A arg) {
5423 apply(rhs, arg);
5424 return null;
5425 }
5426
5427 @override
5428 R visitUnresolvedTopLevelSetterCompound(
5429 Send node,
5430 MethodElement getter,
5431 Element element,
5432 AssignmentOperator operator,
5433 Node rhs,
5434 A arg) {
5435 apply(rhs, arg);
5436 return null;
5437 }
5438
5439 @override
5440 R visitStaticMethodCompound(
5441 Send node,
5442 MethodElement method,
5443 AssignmentOperator operator,
5444 Node rhs,
5445 A arg) {
5446 apply(rhs, arg);
5447 return null;
5448 }
5449
5450 @override
5451 R visitUnresolvedStaticGetterPrefix(
5452 Send node,
5453 Element element,
5454 MethodElement setter,
5455 IncDecOperator operator,
5456 A arg) {
5457 return null;
5458 }
5459
5460 @override
5461 R visitUnresolvedTopLevelGetterPrefix(
5462 Send node,
5463 Element element,
5464 MethodElement setter,
5465 IncDecOperator operator,
5466 A arg) {
5467 return null;
5468 }
5469
5470 @override
5471 R visitUnresolvedStaticSetterPrefix(
5472 Send node,
5473 MethodElement getter,
5474 Element element,
5475 IncDecOperator operator,
5476 A arg) {
5477 return null;
5478 }
5479
5480 @override
5481 R visitUnresolvedTopLevelSetterPrefix(
5482 Send node,
5483 MethodElement getter,
5484 Element element,
5485 IncDecOperator operator,
5486 A arg) {
5487 return null;
5488 }
5489
5490 @override
5491 R visitStaticMethodPrefix(
5492 Send node,
5493 MethodElement method,
5494 IncDecOperator operator,
5495 A arg) {
5496 return null;
5497 }
5498
5499 @override
5500 R visitTopLevelMethodPrefix(
5501 Send node,
5502 MethodElement method,
5503 IncDecOperator operator,
5504 A arg) {
5505 return null;
5506 }
5507
5508 @override
5509 R visitUnresolvedStaticGetterPostfix(
5510 Send node,
5511 Element element,
5512 MethodElement setter,
5513 IncDecOperator operator,
5514 A arg) {
5515 return null;
5516 }
5517
5518 @override
5519 R visitUnresolvedTopLevelGetterPostfix(
5520 Send node,
5521 Element element,
5522 MethodElement setter,
5523 IncDecOperator operator,
5524 A arg) {
5525 return null;
5526 }
5527
5528 @override
5529 R visitUnresolvedStaticSetterPostfix(
5530 Send node,
5531 MethodElement getter,
5532 Element element,
5533 IncDecOperator operator,
5534 A arg) {
5535 return null;
5536 }
5537
5538 @override
5539 R visitUnresolvedTopLevelSetterPostfix(
5540 Send node,
5541 MethodElement getter,
5542 Element element,
5543 IncDecOperator operator,
5544 A arg) {
5545 return null;
5546 }
5547
5548 @override
5549 R visitStaticMethodPostfix(
5550 Send node,
5551 MethodElement method,
5552 IncDecOperator operator,
5553 A arg) {
5554 return null;
5555 }
5556
5557 @override
5558 R visitTopLevelMethodPostfix(
5559 Send node,
5560 MethodElement method,
5561 IncDecOperator operator,
5562 A arg) {
5563 return null;
5564 }
5565
5566 @override
5567 R visitFinalLocalVariablePostfix(
5568 Send node,
5569 LocalVariableElement variable,
5570 IncDecOperator operator,
5571 A arg) {
5572 return null;
5573 }
5574
5575 @override
5576 R visitFinalLocalVariablePrefix(
5577 Send node,
5578 LocalVariableElement variable,
5579 IncDecOperator operator,
5580 A arg) {
5581 return null;
5582 }
5583
5584 @override
5585 R visitFinalParameterPostfix(
5586 Send node,
5587 ParameterElement parameter,
5588 IncDecOperator operator,
5589 A arg) {
5590 return null;
5591 }
5592
5593 @override
5594 R visitFinalParameterPrefix(
5595 Send node,
5596 ParameterElement parameter,
5597 IncDecOperator operator,
5598 A arg) {
5599 return null;
5600 }
5601
5602 @override
5603 R visitStaticFinalFieldPostfix(
5604 Send node,
5605 FieldElement field,
5606 IncDecOperator operator,
5607 A arg) {
5608 return null;
5609 }
5610
5611 @override
5612 R visitStaticFinalFieldPrefix(
5613 Send node,
5614 FieldElement field,
5615 IncDecOperator operator,
5616 A arg) {
5617 return null;
5618 }
5619
5620 @override
5621 R visitSuperFieldFieldCompound(
5622 Send node, FieldElement readField,
5623 FieldElement writtenField,
5624 AssignmentOperator operator,
5625 Node rhs,
5626 A arg) {
5627 apply(rhs, arg);
5628 return null;
5629 }
5630
5631 @override
5632 R visitSuperFinalFieldCompound(
5633 Send node,
5634 FieldElement field,
5635 AssignmentOperator operator,
5636 Node rhs,
5637 A arg) {
5638 apply(rhs, arg);
5639 return null;
5640 }
5641
5642 @override
5643 R visitSuperFinalFieldPostfix(
5644 Send node,
5645 FieldElement field,
5646 IncDecOperator operator,
5647 A arg) {
5648 return null;
5649 }
5650
5651 @override
5652 R visitSuperFinalFieldPrefix(
5653 Send node,
5654 FieldElement field,
5655 IncDecOperator operator,
5656 A arg) {
5657 return null;
5658 }
5659
5660 @override
5661 R visitSuperMethodCompound(
5662 Send node,
5663 FunctionElement method,
5664 AssignmentOperator operator,
5665 Node rhs,
5666 A arg) {
5667 apply(rhs, arg);
5668 return null;
5669 }
5670
5671 @override
5672 R visitSuperMethodPostfix(
5673 Send node,
5674 FunctionElement method,
5675 IncDecOperator operator,
5676 A arg) {
5677 return null;
5678 }
5679
5680 @override
5681 R visitSuperMethodPrefix(
5682 Send node,
5683 FunctionElement method,
5684 IncDecOperator operator,
5685 A arg) {
5686 return null;
5687 }
5688
5689 @override
5690 R visitTopLevelFinalFieldPostfix(
5691 Send node,
5692 FieldElement field,
5693 IncDecOperator operator,
5694 A arg) {
5695 return null;
5696 }
5697
5698 @override
5699 R visitTopLevelFinalFieldPrefix(
5700 Send node,
5701 FieldElement field,
5702 IncDecOperator operator,
5703 A arg) {
5704 return null;
5705 }
5706
5707 @override
5708 R visitTopLevelMethodCompound(
5709 Send node,
5710 FunctionElement method,
5711 AssignmentOperator operator,
5712 Node rhs,
5713 A arg) {
5714 apply(rhs, arg);
5715 return null;
5716 }
5717
5718 @override
5719 R visitUnresolvedSuperCompound(
5720 Send node,
5721 Element element,
5722 AssignmentOperator operator,
5723 Node rhs,
5724 A arg) {
5725 apply(rhs, arg);
5726 return null;
5727 }
5728
5729 @override
5730 R visitUnresolvedSuperPostfix(
5731 Send node,
5732 Element element,
5733 IncDecOperator operator,
5734 A arg) {
5735 return null;
5736 }
5737
5738 @override
5739 R visitUnresolvedSuperPrefix(
5740 Send node,
5741 Element element,
5742 IncDecOperator operator,
5743 A arg) {
5744 return null;
5745 }
5746
5747 @override
5748 R visitUnresolvedSuperGetterCompound(
5749 Send node, Element element,
5750 MethodElement setter,
5751 AssignmentOperator operator,
5752 Node rhs,
5753 A arg) {
5754 apply(rhs, arg);
5755 return null;
5756 }
5757
5758 @override
5759 R visitUnresolvedSuperGetterPostfix(
5760 Send node,
5761 Element element,
5762 MethodElement setter,
5763 IncDecOperator operator,
5764 A arg) {
5765 return null;
5766 }
5767
5768 @override
5769 R visitUnresolvedSuperGetterPrefix(
5770 Send node,
5771 Element element,
5772 MethodElement setter,
5773 IncDecOperator operator,
5774 A arg) {
5775 return null;
5776 }
5777
5778 @override
5779 R visitUnresolvedSuperSetterCompound(
5780 Send node, MethodElement getter,
5781 Element element,
5782 AssignmentOperator operator,
5783 Node rhs,
5784 A arg) {
5785 apply(rhs, arg);
5786 return null;
5787 }
5788
5789 @override
5790 R visitUnresolvedSuperSetterPostfix(
5791 Send node,
5792 MethodElement getter,
5793 Element element,
5794 IncDecOperator operator,
5795 A arg) {
5796 return null;
5797 }
5798
5799 @override
5800 R visitUnresolvedSuperSetterPrefix(
5801 Send node,
5802 MethodElement getter,
5803 Element element,
5804 IncDecOperator operator,
5805 A arg) {
5806 return null;
5807 }
4992 } 5808 }
4993 5809
4994 /// [SemanticDeclarationVisitor] that visits subnodes. 5810 /// [SemanticDeclarationVisitor] that visits subnodes.
4995 class TraversalDeclarationMixin<R, A> 5811 class TraversalDeclarationMixin<R, A>
4996 implements SemanticDeclarationVisitor<R, A> { 5812 implements SemanticDeclarationVisitor<R, A> {
4997 @override 5813 @override
4998 R apply(Node node, A arg) { 5814 R apply(Node node, A arg) {
4999 throw new UnimplementedError("TraversalMixin.apply unimplemented"); 5815 throw new UnimplementedError("TraversalMixin.apply unimplemented");
5000 } 5816 }
5001 5817
(...skipping 601 matching lines...) Expand 10 before | Expand all | Expand 10 after
5603 R visitStaticFieldPostfix( 6419 R visitStaticFieldPostfix(
5604 Send node, 6420 Send node,
5605 FieldElement field, 6421 FieldElement field,
5606 IncDecOperator operator, 6422 IncDecOperator operator,
5607 A arg) { 6423 A arg) {
5608 return handleStaticFieldPostfixPrefix( 6424 return handleStaticFieldPostfixPrefix(
5609 node, field, operator, arg, isPrefix: false); 6425 node, field, operator, arg, isPrefix: false);
5610 } 6426 }
5611 6427
5612 @override 6428 @override
6429 R visitStaticFieldPrefix(
6430 Send node,
6431 FieldElement field,
6432 IncDecOperator operator,
6433 A arg) {
6434 return handleStaticFieldPostfixPrefix(
6435 node, field, operator, arg, isPrefix: true);
6436 }
6437
6438 @override
6439 R visitStaticFieldSet(
6440 SendSet node,
6441 FieldElement field,
6442 Node rhs,
6443 A arg) {
6444 return handleStaticFieldSet(node, field, rhs, arg);
6445 }
6446
6447 @override
6448 R visitStaticFunctionGet(
6449 Send node,
6450 MethodElement function,
6451 A arg) {
6452 return handleStaticFunctionGet(node, function, arg);
6453 }
6454
6455 @override
6456 R visitStaticFunctionInvoke(
6457 Send node,
6458 MethodElement function,
6459 NodeList arguments,
6460 CallStructure callStructure,
6461 A arg) {
6462 return handleStaticFunctionInvoke(
6463 node, function, arguments, callStructure, arg);
6464 }
6465
6466 @override
6467 R visitStaticFunctionIncompatibleInvoke(
6468 Send node,
6469 MethodElement function,
6470 NodeList arguments,
6471 CallStructure callStructure,
6472 A arg) {
6473 return handleStaticFunctionIncompatibleInvoke(
6474 node, function, arguments, callStructure, arg);
6475 }
6476
6477 @override
6478 R visitStaticGetterGet(
6479 Send node,
6480 FunctionElement getter,
6481 A arg) {
6482 return handleStaticGetterGet(node, getter, arg);
6483 }
6484
6485 @override
6486 R visitStaticGetterInvoke(
6487 Send node,
6488 FunctionElement getter,
6489 NodeList arguments,
6490 CallStructure callStructure,
6491 A arg) {
6492 return handleStaticGetterInvoke(
6493 node, getter, arguments, callStructure, arg);
6494 }
6495
6496 @override
6497 R visitStaticGetterSetterCompound(
6498 Send node,
6499 FunctionElement getter,
6500 FunctionElement setter,
6501 AssignmentOperator operator,
6502 Node rhs,
6503 A arg) {
6504 return handleStaticGetterSetterCompound(
6505 node, getter, setter, operator, rhs, arg);
6506 }
6507
6508 @override
6509 R visitStaticGetterSetterPostfix(
6510 Send node,
6511 FunctionElement getter,
6512 FunctionElement setter,
6513 IncDecOperator operator,
6514 A arg) {
6515 return handleStaticGetterSetterPostfixPrefix(
6516 node, getter, setter, operator, arg, isPrefix: false);
6517 }
6518
6519 @override
6520 R visitStaticGetterSetterPrefix(
6521 Send node,
6522 FunctionElement getter,
6523 FunctionElement setter,
6524 IncDecOperator operator,
6525 A arg) {
6526 return handleStaticGetterSetterPostfixPrefix(
6527 node, getter, setter, operator, arg, isPrefix: true);
6528 }
6529
6530 @override
6531 R visitStaticMethodSetterCompound(
6532 Send node,
6533 FunctionElement method,
6534 FunctionElement setter,
6535 AssignmentOperator operator,
6536 Node rhs,
6537 A arg) {
6538 return handleStaticMethodSetterCompound(
6539 node, method, setter, operator, rhs, arg);
6540 }
6541
6542 @override
6543 R visitStaticMethodSetterPostfix(
6544 Send node,
6545 FunctionElement getter,
6546 FunctionElement setter,
6547 IncDecOperator operator,
6548 A arg) {
6549 return handleStaticMethodSetterPostfixPrefix(
6550 node, getter, setter, operator, arg, isPrefix: false);
6551 }
6552
6553 @override
6554 R visitStaticMethodSetterPrefix(
6555 Send node,
6556 FunctionElement getter,
6557 FunctionElement setter,
6558 IncDecOperator operator,
6559 A arg) {
6560 return handleStaticMethodSetterPostfixPrefix(
6561 node, getter, setter, operator, arg, isPrefix: true);
6562 }
6563
6564 @override
6565 R visitStaticSetterSet(
6566 SendSet node,
6567 FunctionElement setter,
6568 Node rhs,
6569 A arg) {
6570 return handleStaticSetterSet(node, setter, rhs, arg);
6571 }
6572
6573 @override
6574 R visitTopLevelFieldCompound(
6575 Send node,
6576 FieldElement field,
6577 AssignmentOperator operator,
6578 Node rhs,
6579 A arg) {
6580 return handleStaticFieldCompound(node, field, operator, rhs, arg);
6581 }
6582
6583 @override
6584 R visitTopLevelFieldGet(
6585 Send node,
6586 FieldElement field,
6587 A arg) {
6588 return handleStaticFieldGet(node, field, arg);
6589 }
6590
6591 @override
6592 R visitTopLevelFieldInvoke(
6593 Send node,
6594 FieldElement field,
6595 NodeList arguments,
6596 CallStructure callStructure,
6597 A arg) {
6598 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
6599 }
6600
6601 @override
6602 R visitTopLevelFieldPostfix(
6603 Send node,
6604 FieldElement field,
6605 IncDecOperator operator,
6606 A arg) {
6607 return handleStaticFieldPostfixPrefix(
6608 node, field, operator, arg, isPrefix: false);
6609 }
6610
6611 @override
6612 R visitTopLevelFieldPrefix(
6613 Send node,
6614 FieldElement field,
6615 IncDecOperator operator,
6616 A arg) {
6617 return handleStaticFieldPostfixPrefix(
6618 node, field, operator, arg, isPrefix: true);
6619 }
6620
6621 @override
6622 R visitTopLevelFieldSet(
6623 SendSet node,
6624 FieldElement field,
6625 Node rhs,
6626 A arg) {
6627 return handleStaticFieldSet(node, field, rhs, arg);
6628 }
6629
6630 @override
6631 R visitTopLevelFunctionGet(
6632 Send node,
6633 MethodElement function,
6634 A arg) {
6635 return handleStaticFunctionGet(node, function, arg);
6636 }
6637
6638 @override
6639 R visitTopLevelFunctionInvoke(
6640 Send node,
6641 MethodElement function,
6642 NodeList arguments,
6643 CallStructure callStructure,
6644 A arg) {
6645 return handleStaticFunctionInvoke(
6646 node, function, arguments, callStructure, arg);
6647 }
6648
6649 @override
6650 R visitTopLevelFunctionIncompatibleInvoke(
6651 Send node,
6652 MethodElement function,
6653 NodeList arguments,
6654 CallStructure callStructure,
6655 A arg) {
6656 return handleStaticFunctionIncompatibleInvoke(
6657 node, function, arguments, callStructure, arg);
6658 }
6659
6660 @override
6661 R visitTopLevelGetterGet(
6662 Send node,
6663 FunctionElement getter,
6664 A arg) {
6665 return handleStaticGetterGet(node, getter, arg);
6666 }
6667
6668 @override
6669 R visitTopLevelGetterInvoke(
6670 Send node,
6671 FunctionElement getter,
6672 NodeList arguments,
6673 CallStructure callStructure,
6674 A arg) {
6675 return handleStaticGetterInvoke(
6676 node, getter, arguments, callStructure, arg);
6677 }
6678
6679 @override
6680 R visitTopLevelGetterSetterCompound(
6681 Send node,
6682 FunctionElement getter,
6683 FunctionElement setter,
6684 AssignmentOperator operator,
6685 Node rhs,
6686 A arg) {
6687 return handleStaticGetterSetterCompound(
6688 node, getter, setter, operator, rhs, arg);
6689 }
6690
6691 @override
6692 R visitTopLevelGetterSetterPostfix(
6693 Send node,
6694 FunctionElement getter,
6695 FunctionElement setter,
6696 IncDecOperator operator,
6697 A arg) {
6698 return handleStaticGetterSetterPostfixPrefix(
6699 node, getter, setter, operator, arg, isPrefix: false);
6700 }
6701
6702 @override
6703 R visitTopLevelGetterSetterPrefix(
6704 Send node,
6705 FunctionElement getter,
6706 FunctionElement setter,
6707 IncDecOperator operator,
6708 A arg) {
6709 return handleStaticGetterSetterPostfixPrefix(
6710 node, getter, setter, operator, arg, isPrefix: true);
6711 }
6712
6713 @override
6714 R visitTopLevelMethodSetterCompound(
6715 Send node,
6716 FunctionElement method,
6717 FunctionElement setter,
6718 AssignmentOperator operator,
6719 Node rhs,
6720 A arg) {
6721 return handleStaticMethodSetterCompound(
6722 node, method, setter, operator, rhs, arg);
6723 }
6724
6725 @override
6726 R visitTopLevelMethodSetterPostfix(
6727 Send node,
6728 FunctionElement method,
6729 FunctionElement setter,
6730 IncDecOperator operator,
6731 A arg) {
6732 return handleStaticMethodSetterPostfixPrefix(
6733 node, method, setter, operator, arg, isPrefix: false);
6734 }
6735
6736 @override
6737 R visitTopLevelMethodSetterPrefix(
6738 Send node,
6739 FunctionElement method,
6740 FunctionElement setter,
6741 IncDecOperator operator,
6742 A arg) {
6743 return handleStaticMethodSetterPostfixPrefix(
6744 node, method, setter, operator, arg, isPrefix: true);
6745 }
6746
6747 @override
6748 R visitTopLevelSetterSet(
6749 SendSet node,
6750 FunctionElement setter,
6751 Node rhs,
6752 A arg) {
6753 return handleStaticSetterSet(node, setter, rhs, arg);
6754 }
6755 }
6756
6757 /// Mixin that groups all `visitLocalX` and `visitParameterX` method by
6758 /// delegating calls to `handleLocalX` methods.
6759 ///
6760 /// This mixin is useful for the cases where both parameters, local variables,
6761 /// and local functions, captured or not, are handled uniformly.
6762 abstract class BaseImplementationOfLocalsMixin<R, A>
6763 implements SemanticSendVisitor<R, A> {
6764 R handleLocalCompound(
6765 Send node,
6766 LocalElement element,
6767 AssignmentOperator operator,
6768 Node rhs,
6769 A arg);
6770
6771 R handleLocalGet(
6772 Send node,
6773 LocalElement element,
6774 A arg);
6775
6776 R handleLocalInvoke(
6777 Send node,
6778 LocalElement element,
6779 NodeList arguments,
6780 CallStructure callStructure,
6781 A arg);
6782
6783 R handleLocalPostfixPrefix(
6784 Send node,
6785 LocalElement element,
6786 IncDecOperator operator,
6787 A arg,
6788 {bool isPrefix});
6789
6790 R handleLocalSet(
6791 SendSet node,
6792 LocalElement element,
6793 Node rhs,
6794 A arg);
6795
6796 @override
6797 R visitLocalFunctionGet(
6798 Send node,
6799 LocalFunctionElement function,
6800 A arg) {
6801 return handleLocalGet(node, function, arg);
6802 }
6803
6804 @override
6805 R visitLocalFunctionInvoke(
6806 Send node,
6807 LocalFunctionElement function,
6808 NodeList arguments,
6809 CallStructure callStructure,
6810 A arg) {
6811 return handleLocalInvoke(node, function, arguments, callStructure, arg);
6812 }
6813
6814 @override
6815 R visitLocalVariableCompound(
6816 Send node,
6817 LocalVariableElement variable,
6818 AssignmentOperator operator,
6819 Node rhs,
6820 A arg) {
6821 return handleLocalCompound(node, variable, operator, rhs, arg);
6822 }
6823
6824 @override
6825 R visitLocalVariableGet(
6826 Send node,
6827 LocalVariableElement variable,
6828 A arg) {
6829 return handleLocalGet(node, variable, arg);
6830 }
6831
6832 @override
6833 R visitLocalVariableInvoke(
6834 Send node,
6835 LocalVariableElement variable,
6836 NodeList arguments,
6837 CallStructure callStructure,
6838 A arg) {
6839 return handleLocalInvoke(node, variable, arguments, callStructure, arg);
6840 }
6841
6842 @override
6843 R visitLocalVariablePostfix(
6844 Send node,
6845 LocalVariableElement variable,
6846 IncDecOperator operator,
6847 A arg) {
6848 return handleLocalPostfixPrefix(
6849 node, variable, operator, arg, isPrefix: false);
6850 }
6851
6852 @override
6853 R visitLocalVariablePrefix(
6854 Send node,
6855 LocalVariableElement variable,
6856 IncDecOperator operator,
6857 A arg) {
6858 return handleLocalPostfixPrefix(
6859 node, variable, operator, arg, isPrefix: true);
6860 }
6861
6862 @override
6863 R visitLocalVariableSet(
6864 SendSet node,
6865 LocalVariableElement variable,
6866 Node rhs,
6867 A arg) {
6868 return handleLocalSet(node, variable, rhs, arg);
6869 }
6870
6871 @override
6872 R visitParameterCompound(
6873 Send node,
6874 ParameterElement parameter,
6875 AssignmentOperator operator,
6876 Node rhs,
6877 A arg) {
6878 return handleLocalCompound(node, parameter, operator, rhs, arg);
6879 }
6880
6881 @override
6882 R visitParameterGet(
6883 Send node,
6884 ParameterElement parameter,
6885 A arg) {
6886 return handleLocalGet(node, parameter, arg);
6887 }
6888
6889 @override
6890 R visitParameterInvoke(
6891 Send node,
6892 ParameterElement parameter,
6893 NodeList arguments,
6894 CallStructure callStructure,
6895 A arg) {
6896 return handleLocalInvoke(node, parameter, arguments, callStructure, arg);
6897 }
6898
6899 @override
6900 R visitParameterPostfix(
6901 Send node,
6902 ParameterElement parameter,
6903 IncDecOperator operator,
6904 A arg) {
6905 return handleLocalPostfixPrefix(
6906 node, parameter, operator, arg, isPrefix: false);
6907 }
6908
6909 @override
6910 R visitParameterPrefix(
6911 Send node,
6912 ParameterElement parameter,
6913 IncDecOperator operator,
6914 A arg) {
6915 return handleLocalPostfixPrefix(
6916 node, parameter, operator, arg, isPrefix: true);
6917 }
6918
6919 @override
6920 R visitParameterSet(
6921 SendSet node,
6922 ParameterElement parameter,
6923 Node rhs,
6924 A arg) {
6925 return handleLocalSet(node, parameter, rhs, arg);
6926 }
6927 }
6928
6929 /// Mixin that groups all `visitConstantX` and `visitXTypeLiteralY` methods for
6930 /// constant type literals by delegating calls to `handleConstantX` methods.
6931 ///
6932 /// This mixin is useful for the cases where expressions on constants are
6933 /// handled uniformly.
6934 abstract class BaseImplementationOfConstantsMixin<R, A>
6935 implements SemanticSendVisitor<R, A> {
6936 R handleConstantGet(
6937 Node node,
6938 ConstantExpression constant,
6939 A arg);
6940
6941 R handleConstantInvoke(
6942 Send node,
6943 ConstantExpression constant,
6944 NodeList arguments,
6945 CallStructure callStructure,
6946 A arg);
6947
6948 @override
6949 R visitClassTypeLiteralGet(
6950 Send node,
6951 ConstantExpression constant,
6952 A arg) {
6953 return handleConstantGet(node, constant, arg);
6954 }
6955
6956 @override
6957 R visitClassTypeLiteralInvoke(
6958 Send node,
6959 ConstantExpression constant,
6960 NodeList arguments,
6961 CallStructure callStructure,
6962 A arg) {
6963 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
6964 }
6965
6966 @override
6967 R visitConstConstructorInvoke(
6968 NewExpression node,
6969 ConstructedConstantExpression constant,
6970 A arg) {
6971 return handleConstantGet(node, constant, arg);
6972 }
6973
6974 @override
6975 R visitConstantGet(
6976 Send node,
6977 ConstantExpression constant,
6978 A arg) {
6979 return handleConstantGet(node, constant, arg);
6980 }
6981
6982 @override
6983 R visitConstantInvoke(
6984 Send node,
6985 ConstantExpression constant,
6986 NodeList arguments,
6987 CallStructure callStructure,
6988 A arg) {
6989 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
6990 }
6991
6992 @override
6993 R visitDynamicTypeLiteralGet(
6994 Send node,
6995 ConstantExpression constant,
6996 A arg) {
6997 return handleConstantGet(node, constant, arg);
6998 }
6999
7000 @override
7001 R visitDynamicTypeLiteralInvoke(
7002 Send node,
7003 ConstantExpression constant,
7004 NodeList arguments,
7005 CallStructure callStructure,
7006 A arg) {
7007 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
7008 }
7009
7010 @override
7011 R visitTypedefTypeLiteralGet(
7012 Send node,
7013 ConstantExpression constant,
7014 A arg) {
7015 return handleConstantGet(node, constant, arg);
7016 }
7017
7018 @override
7019 R visitTypedefTypeLiteralInvoke(
7020 Send node,
7021 ConstantExpression constant,
7022 NodeList arguments,
7023 CallStructure callStructure,
7024 A arg) {
7025 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
7026 }
7027 }
7028
7029 /// Mixin that groups all `visitDynamicPropertyX` and `visitThisPropertyY`
7030 /// methods for by delegating calls to `handleDynamicX` methods, providing
7031 /// `null` as the receiver for the this properties.
7032 ///
7033 /// This mixin is useful for the cases where dynamic and this properties are
7034 /// handled uniformly.
7035 abstract class BaseImplementationOfDynamicsMixin<R, A>
7036 implements SemanticSendVisitor<R, A> {
7037 R handleDynamicCompound(
7038 Send node,
7039 Node receiver,
7040 AssignmentOperator operator,
7041 Node rhs,
7042 Selector getterSelector,
7043 Selector setterSelector,
7044 A arg);
7045
7046 R handleDynamicGet(
7047 Send node,
7048 Node receiver,
7049 Selector selector,
7050 A arg);
7051
7052 R handleDynamicInvoke(
7053 Send node,
7054 Node receiver,
7055 NodeList arguments,
7056 Selector selector,
7057 A arg);
7058
7059 R handleDynamicPostfixPrefix(
7060 Send node,
7061 Node receiver,
7062 IncDecOperator operator,
7063 Selector getterSelector,
7064 Selector setterSelector,
7065 A arg,
7066 {bool isPrefix});
7067
7068 R handleDynamicSet(
7069 SendSet node,
7070 Node receiver,
7071 Selector selector,
7072 Node rhs,
7073 A arg);
7074
7075 R handleDynamicIndexPostfixPrefix(
7076 Send node,
7077 Node receiver,
7078 Node index,
7079 IncDecOperator operator,
7080 A arg,
7081 {bool isPrefix});
7082
7083 @override
7084 R visitDynamicPropertyCompound(
7085 Send node,
7086 Node receiver,
7087 AssignmentOperator operator,
7088 Node rhs,
7089 Selector getterSelector,
7090 Selector setterSelector,
7091 A arg) {
7092 return handleDynamicCompound(
7093 node, receiver, operator, rhs, getterSelector, setterSelector, arg);
7094 }
7095
7096 @override
7097 R visitDynamicPropertyGet(
7098 Send node,
7099 Node receiver,
7100 Selector selector,
7101 A arg) {
7102 return handleDynamicGet(node, receiver, selector, arg);
7103 }
7104
7105 @override
7106 R visitDynamicPropertyInvoke(
7107 Send node,
7108 Node receiver,
7109 NodeList arguments,
7110 Selector selector,
7111 A arg) {
7112 return handleDynamicInvoke(node, receiver, arguments, selector, arg);
7113 }
7114
7115 @override
7116 R visitDynamicPropertyPostfix(
7117 Send node,
7118 Node receiver,
7119 IncDecOperator operator,
7120 Selector getterSelector,
7121 Selector setterSelector,
7122 A arg) {
7123 return handleDynamicPostfixPrefix(
7124 node, receiver, operator,
7125 getterSelector, setterSelector, arg, isPrefix: false);
7126 }
7127
7128 @override
7129 R visitDynamicPropertyPrefix(
7130 Send node,
7131 Node receiver,
7132 IncDecOperator operator,
7133 Selector getterSelector,
7134 Selector setterSelector,
7135 A arg) {
7136 return handleDynamicPostfixPrefix(
7137 node, receiver, operator,
7138 getterSelector, setterSelector, arg, isPrefix: true);
7139 }
7140
7141 @override
7142 R visitDynamicPropertySet(
7143 SendSet node,
7144 Node receiver,
7145 Selector selector,
7146 Node rhs,
7147 A arg) {
7148 return handleDynamicSet(node, receiver, selector, rhs, arg);
7149 }
7150
7151 @override
7152 R visitThisPropertyCompound(
7153 Send node,
7154 AssignmentOperator operator,
7155 Node rhs,
7156 Selector getterSelector,
7157 Selector setterSelector,
7158 A arg) {
7159 return handleDynamicCompound(
7160 node, null, operator, rhs, getterSelector, setterSelector, arg);
7161 }
7162
7163 @override
7164 R visitThisPropertyGet(
7165 Send node,
7166 Selector selector,
7167 A arg) {
7168 return handleDynamicGet(node, null, selector, arg);
7169 }
7170
7171 @override
7172 R visitThisPropertyInvoke(
7173 Send node,
7174 NodeList arguments,
7175 Selector selector,
7176 A arg) {
7177 return handleDynamicInvoke(node, null, arguments, selector, arg);
7178 }
7179
7180 @override
7181 R visitThisPropertyPostfix(
7182 Send node,
7183 IncDecOperator operator,
7184 Selector getterSelector,
7185 Selector setterSelector,
7186 A arg) {
7187 return handleDynamicPostfixPrefix(
7188 node, null, operator,
7189 getterSelector, setterSelector, arg, isPrefix: false);
7190 }
7191
7192 @override
7193 R visitThisPropertyPrefix(
7194 Send node,
7195 IncDecOperator operator,
7196 Selector getterSelector,
7197 Selector setterSelector,
7198 A arg) {
7199 return handleDynamicPostfixPrefix(
7200 node, null, operator,
7201 getterSelector, setterSelector, arg, isPrefix: true);
7202 }
7203
7204 @override
7205 R visitThisPropertySet(
7206 SendSet node,
7207 Selector selector,
7208 Node rhs,
7209 A arg) {
7210 return handleDynamicSet(node, null, selector, rhs, arg);
7211 }
7212
7213 @override
7214 R visitIndexPostfix(
7215 Send node,
7216 Node receiver,
7217 Node index,
7218 IncDecOperator operator,
7219 A arg) {
7220 return handleDynamicIndexPostfixPrefix(
7221 node, receiver, index, operator, arg, isPrefix: false);
7222 }
7223
7224 @override
7225 R visitIndexPrefix(
7226 Send node,
7227 Node receiver,
7228 Node index,
7229 IncDecOperator operator,
7230 A arg) {
7231 return handleDynamicIndexPostfixPrefix(
7232 node, receiver, index, operator, arg, isPrefix: true);
7233 }
7234 }
7235
7236 /// The getter kind for statically resolved compound expressions.
7237 enum CompoundGetter {
7238 /// The compound reads from a field.
7239 FIELD,
7240
7241 /// The compound reads from a getter.
7242 GETTER,
7243
7244 /// The compound reads (closurizes) a method.
7245 METHOD,
7246
7247 /// The getter is unresolved. The accompanied element is an erroneous element.
7248 UNRESOLVED,
7249 }
7250
7251 /// The setter kind for statically resolved compound expressions.
7252 enum CompoundSetter {
7253 /// The compound writes to a field.
7254 FIELD,
7255
7256 /// The compound writes to a setter.
7257 SETTER,
7258
7259 /// The setter is unresolved or unassignable. The accompanied element may be
7260 /// `null`, and erroneous element, or the unassignable element.
7261 INVALID,
7262 }
7263
7264 /// The kind of a [CompoundRhs].
7265 enum CompoundKind {
7266 /// A prefix expression, like `--a`.
7267 PREFIX,
7268
7269 /// A postfix expression, like `a++`.
7270 POSTFIX,
7271
7272 /// A compound assignment, like `a *= b`.
7273 ASSIGNMENT,
7274 }
7275
7276 /// The right-hand side of a compound expression.
7277 abstract class CompoundRhs {
7278 /// The kind of compound.
7279 CompoundKind get kind;
7280
7281 /// The binary operator implied by the compound operator.
7282 BinaryOperator get operator;
7283
7284 /// The explicit right hand side in case of a compound assignment, `null`
7285 /// otherwise.
7286 Node get rhs;
7287 }
7288
7289 /// A prefix or postfix of [incDecOperator].
7290 class IncDecCompound implements CompoundRhs {
7291 final CompoundKind kind;
7292 final IncDecOperator incDecOperator;
7293
7294 IncDecCompound(this.kind, this.incDecOperator);
7295
7296 BinaryOperator get operator => incDecOperator.binaryOperator;
7297
7298 Node get rhs => null;
7299 }
7300
7301 /// A compound assignment with [assignmentOperator] and [rhs].
7302 class AssignmentCompound implements CompoundRhs {
7303 final AssignmentOperator assignmentOperator;
7304 final Node rhs;
7305
7306 AssignmentCompound(this.assignmentOperator, this.rhs);
7307
7308 CompoundKind get kind => CompoundKind.ASSIGNMENT;
7309
7310 BinaryOperator get operator => assignmentOperator.binaryOperator;
7311 }
7312
7313 /// Simplified handling of compound assignments and prefix/postfix expressions.
7314 abstract class BaseImplementationOfCompoundsMixin<R, A>
7315 implements SemanticSendVisitor<R, A> {
7316
7317 /// Handle a super compound, like `super.foo += 42` or `--super.bar`.
7318 R handleSuperCompound(
7319 SendSet node,
7320 Element getter,
7321 CompoundGetter getterKind,
7322 Element setter,
7323 CompoundSetter setterKind,
7324 CompoundRhs rhs,
7325 A arg);
7326
7327 /// Handle a static or top level compound, like `foo += 42` or `--bar`.
7328 R handleStaticCompound(
7329 SendSet node,
7330 Element getter,
7331 CompoundGetter getterKind,
7332 Element setter,
7333 CompoundSetter setterKind,
7334 CompoundRhs rhs,
7335 A arg);
7336
7337 /// Handle a local compound, like `foo += 42` or `--bar`. If [isSetterValid]
7338 /// is false [local] is unassignable.
7339 R handleLocalCompound(
7340 SendSet node,
7341 LocalElement local,
7342 CompoundRhs rhs,
7343 A arg,
7344 {bool isSetterValid});
7345
7346 /// Handle a compound on a constant, like `Object += 42` or `--Object`.
7347 R handleConstantCompound(
7348 SendSet node,
7349 ConstantExpression constant,
7350 CompoundRhs rhs,
7351 A arg);
7352
7353 /// Handle a compound on a type variable type literal, like `T += 42` or
7354 /// `--T`.
7355 R handleTypeVariableTypeLiteralCompound(
7356 SendSet node,
7357 TypeVariableElement typeVariable,
7358 CompoundRhs rhs,
7359 A arg);
7360
7361 /// Handle a dynamic compound, like `o.foo += 42` or `--o.foo`. [receiver] is
7362 /// `null` for properties on `this`, like `--this.foo` or `--foo`.
7363 R handleDynamicCompound(
7364 Send node,
7365 Node receiver,
7366 CompoundRhs rhs,
7367 Selector getterSelector,
7368 Selector setterSelector,
7369 A arg);
7370
7371 R visitDynamicPropertyCompound(
7372 Send node,
7373 Node receiver,
7374 AssignmentOperator operator,
7375 Node rhs,
7376 Selector getterSelector,
7377 Selector setterSelector,
7378 A arg) {
7379 return handleDynamicCompound(
7380 node,
7381 receiver,
7382 new AssignmentCompound(operator, rhs),
7383 getterSelector,
7384 setterSelector,
7385 arg);
7386 }
7387
7388 @override
7389 R visitThisPropertyCompound(
7390 Send node,
7391 AssignmentOperator operator,
7392 Node rhs,
7393 Selector getterSelector,
7394 Selector setterSelector,
7395 A arg) {
7396 return handleDynamicCompound(
7397 node,
7398 null,
7399 new AssignmentCompound(operator, rhs),
7400 getterSelector,
7401 setterSelector,
7402 arg);
7403 }
7404
7405 @override
7406 R visitParameterCompound(
7407 Send node,
7408 ParameterElement parameter,
7409 AssignmentOperator operator,
7410 Node rhs,
7411 A arg) {
7412 return handleLocalCompound(
7413 node,
7414 parameter,
7415 new AssignmentCompound(operator, rhs),
7416 arg,
7417 isSetterValid: true);
7418 }
7419
7420 @override
7421 R visitFinalParameterCompound(
7422 Send node,
7423 ParameterElement parameter,
7424 AssignmentOperator operator,
7425 Node rhs,
7426 A arg) {
7427 return handleLocalCompound(
7428 node,
7429 parameter,
7430 new AssignmentCompound(operator, rhs),
7431 arg,
7432 isSetterValid: false);
7433 }
7434
7435 @override
7436 R visitLocalVariableCompound(
7437 Send node,
7438 LocalVariableElement variable,
7439 AssignmentOperator operator,
7440 Node rhs,
7441 A arg) {
7442 return handleLocalCompound(
7443 node,
7444 variable,
7445 new AssignmentCompound(operator, rhs),
7446 arg,
7447 isSetterValid: true);
7448 }
7449
7450 @override
7451 R visitFinalLocalVariableCompound(
7452 Send node,
7453 LocalVariableElement variable,
7454 AssignmentOperator operator,
7455 Node rhs,
7456 A arg) {
7457 return handleLocalCompound(
7458 node,
7459 variable,
7460 new AssignmentCompound(operator, rhs),
7461 arg,
7462 isSetterValid: false);
7463 }
7464
7465 @override
7466 R visitLocalFunctionCompound(
7467 Send node,
7468 LocalFunctionElement function,
7469 AssignmentOperator operator,
7470 Node rhs,
7471 A arg) {
7472 return handleLocalCompound(
7473 node,
7474 function,
7475 new AssignmentCompound(operator, rhs),
7476 arg,
7477 isSetterValid: false);
7478 }
7479
7480 @override
7481 R visitStaticFieldCompound(
7482 Send node,
7483 FieldElement field,
7484 AssignmentOperator operator,
7485 Node rhs,
7486 A arg) {
7487 return handleStaticCompound(
7488 node,
7489 field, CompoundGetter.FIELD,
7490 field, CompoundSetter.FIELD,
7491 new AssignmentCompound(operator, rhs),
7492 arg);
7493 }
7494
7495 @override
7496 R visitStaticFinalFieldCompound(
7497 Send node,
7498 FieldElement field,
7499 AssignmentOperator operator,
7500 Node rhs,
7501 A arg) {
7502 return handleStaticCompound(
7503 node,
7504 field, CompoundGetter.FIELD,
7505 null, CompoundSetter.INVALID,
7506 new AssignmentCompound(operator, rhs),
7507 arg);
7508 }
7509
7510 @override
7511 R visitStaticGetterSetterCompound(
7512 Send node,
7513 FunctionElement getter,
7514 FunctionElement setter,
7515 AssignmentOperator operator,
7516 Node rhs,
7517 A arg) {
7518 return handleStaticCompound(
7519 node,
7520 getter, CompoundGetter.GETTER,
7521 setter, CompoundSetter.SETTER,
7522 new AssignmentCompound(operator, rhs),
7523 arg);
7524 }
7525
7526 @override
7527 R visitStaticMethodSetterCompound(
7528 Send node,
7529 FunctionElement method,
7530 FunctionElement setter,
7531 AssignmentOperator operator,
7532 Node rhs,
7533 A arg) {
7534 return handleStaticCompound(
7535 node,
7536 method, CompoundGetter.METHOD,
7537 setter, CompoundSetter.SETTER,
7538 new AssignmentCompound(operator, rhs),
7539 arg);
7540 }
7541
7542 @override
7543 R visitTopLevelFieldCompound(
7544 Send node,
7545 FieldElement field,
7546 AssignmentOperator operator,
7547 Node rhs,
7548 A arg) {
7549 return handleStaticCompound(
7550 node,
7551 field, CompoundGetter.FIELD,
7552 field, CompoundSetter.FIELD,
7553 new AssignmentCompound(operator, rhs),
7554 arg);
7555 }
7556
7557 @override
7558 R visitTopLevelFinalFieldCompound(
7559 Send node,
7560 FieldElement field,
7561 AssignmentOperator operator,
7562 Node rhs,
7563 A arg) {
7564 return handleStaticCompound(
7565 node,
7566 field, CompoundGetter.FIELD,
7567 null, CompoundSetter.INVALID,
7568 new AssignmentCompound(operator, rhs),
7569 arg);
7570 }
7571
7572 @override
7573 R visitTopLevelGetterSetterCompound(
7574 Send node,
7575 FunctionElement getter,
7576 FunctionElement setter,
7577 AssignmentOperator operator,
7578 Node rhs,
7579 A arg) {
7580 return handleStaticCompound(
7581 node,
7582 getter, CompoundGetter.GETTER,
7583 setter, CompoundSetter.SETTER,
7584 new AssignmentCompound(operator, rhs),
7585 arg);
7586 }
7587
7588 @override
7589 R visitTopLevelMethodSetterCompound(
7590 Send node,
7591 FunctionElement method,
7592 FunctionElement setter,
7593 AssignmentOperator operator,
7594 Node rhs,
7595 A arg) {
7596 return handleStaticCompound(
7597 node,
7598 method, CompoundGetter.METHOD,
7599 setter, CompoundSetter.SETTER,
7600 new AssignmentCompound(operator, rhs),
7601 arg);
7602 }
7603
7604 @override
7605 R visitSuperFieldCompound(
7606 Send node,
7607 FieldElement field,
7608 AssignmentOperator operator,
7609 Node rhs,
7610 A arg) {
7611 return handleSuperCompound(
7612 node,
7613 field, CompoundGetter.FIELD,
7614 field, CompoundSetter.FIELD,
7615 new AssignmentCompound(operator, rhs),
7616 arg);
7617 }
7618
7619 @override
7620 R visitSuperFinalFieldCompound(
7621 Send node,
7622 FieldElement field,
7623 AssignmentOperator operator,
7624 Node rhs,
7625 A arg) {
7626 return handleSuperCompound(
7627 node,
7628 field, CompoundGetter.FIELD,
7629 field, CompoundSetter.INVALID,
7630 new AssignmentCompound(operator, rhs),
7631 arg);
7632 }
7633
7634 @override
7635 R visitSuperGetterSetterCompound(
7636 Send node,
7637 FunctionElement getter,
7638 FunctionElement setter,
7639 AssignmentOperator operator,
7640 Node rhs,
7641 A arg) {
7642 return handleSuperCompound(
7643 node,
7644 getter, CompoundGetter.GETTER,
7645 setter, CompoundSetter.SETTER,
7646 new AssignmentCompound(operator, rhs),
7647 arg);
7648 }
7649
7650 @override
7651 R visitSuperMethodSetterCompound(
7652 Send node,
7653 FunctionElement method,
7654 FunctionElement setter,
7655 AssignmentOperator operator,
7656 Node rhs,
7657 A arg) {
7658 return handleSuperCompound(
7659 node,
7660 method, CompoundGetter.METHOD,
7661 setter, CompoundSetter.SETTER,
7662 new AssignmentCompound(operator, rhs),
7663 arg);
7664 }
7665
7666 @override
7667 R visitSuperFieldSetterCompound(
7668 Send node,
7669 FieldElement field,
7670 FunctionElement setter,
7671 AssignmentOperator operator,
7672 Node rhs,
7673 A arg) {
7674 return handleSuperCompound(
7675 node,
7676 field, CompoundGetter.FIELD,
7677 setter, CompoundSetter.SETTER,
7678 new AssignmentCompound(operator, rhs),
7679 arg);
7680 }
7681
7682 @override
7683 R visitSuperGetterFieldCompound(
7684 Send node,
7685 FunctionElement getter,
7686 FieldElement field,
7687 AssignmentOperator operator,
7688 Node rhs,
7689 A arg) {
7690 return handleSuperCompound(
7691 node,
7692 getter, CompoundGetter.GETTER,
7693 field, CompoundSetter.FIELD,
7694 new AssignmentCompound(operator, rhs),
7695 arg);
7696 }
7697
7698 @override
7699 R visitClassTypeLiteralCompound(
7700 Send node,
7701 ConstantExpression constant,
7702 AssignmentOperator operator,
7703 Node rhs,
7704 A arg) {
7705 return handleConstantCompound(
7706 node,
7707 constant,
7708 new AssignmentCompound(operator, rhs),
7709 arg);
7710 }
7711
7712 @override
7713 R visitTypedefTypeLiteralCompound(
7714 Send node,
7715 ConstantExpression constant,
7716 AssignmentOperator operator,
7717 Node rhs,
7718 A arg) {
7719 return handleConstantCompound(
7720 node,
7721 constant,
7722 new AssignmentCompound(operator, rhs),
7723 arg);
7724 }
7725
7726 @override
7727 R visitTypeVariableTypeLiteralCompound(
7728 Send node,
7729 TypeVariableElement element,
7730 AssignmentOperator operator,
7731 Node rhs,
7732 A arg) {
7733 return handleTypeVariableTypeLiteralCompound(
7734 node,
7735 element,
7736 new AssignmentCompound(operator, rhs),
7737 arg);
7738 }
7739
7740 @override
7741 R visitDynamicTypeLiteralCompound(
7742 Send node,
7743 ConstantExpression constant,
7744 AssignmentOperator operator,
7745 Node rhs,
7746 A arg) {
7747 return handleConstantCompound(
7748 node,
7749 constant,
7750 new AssignmentCompound(operator, rhs),
7751 arg);
7752 }
7753
7754
7755 R visitDynamicPropertyPrefix(
7756 Send node,
7757 Node receiver,
7758 IncDecOperator operator,
7759 Selector getterSelector,
7760 Selector setterSelector,
7761 A arg) {
7762 return handleDynamicCompound(
7763 node,
7764 receiver,
7765 new IncDecCompound(CompoundKind.PREFIX, operator),
7766 getterSelector,
7767 setterSelector,
7768 arg);
7769 }
7770
7771 @override
7772 R visitParameterPrefix(
7773 Send node,
7774 ParameterElement parameter,
7775 IncDecOperator operator,
7776 A arg) {
7777 return handleLocalCompound(
7778 node,
7779 parameter,
7780 new IncDecCompound(CompoundKind.PREFIX, operator),
7781 arg,
7782 isSetterValid: true);
7783 }
7784
7785 @override
7786 R visitLocalVariablePrefix(
7787 Send node,
7788 LocalVariableElement variable,
7789 IncDecOperator operator,
7790 A arg) {
7791 return handleLocalCompound(
7792 node,
7793 variable,
7794 new IncDecCompound(CompoundKind.PREFIX, operator),
7795 arg,
7796 isSetterValid: true);
7797 }
7798
7799 @override
7800 R visitLocalFunctionPrefix(
7801 Send node,
7802 LocalFunctionElement function,
7803 IncDecOperator operator,
7804 A arg) {
7805 return handleLocalCompound(
7806 node,
7807 function,
7808 new IncDecCompound(CompoundKind.PREFIX, operator),
7809 arg,
7810 isSetterValid: false);
7811 }
7812
7813
7814 R visitThisPropertyPrefix(
7815 Send node,
7816 IncDecOperator operator,
7817 Selector getterSelector,
7818 Selector setterSelector,
7819 A arg) {
7820 return handleDynamicCompound(
7821 node,
7822 null,
7823 new IncDecCompound(CompoundKind.PREFIX, operator),
7824 getterSelector,
7825 setterSelector,
7826 arg);
7827 }
7828
7829 @override
5613 R visitStaticFieldPrefix( 7830 R visitStaticFieldPrefix(
5614 Send node, 7831 Send node,
5615 FieldElement field, 7832 FieldElement field,
5616 IncDecOperator operator, 7833 IncDecOperator operator,
5617 A arg) { 7834 A arg) {
5618 return handleStaticFieldPostfixPrefix( 7835 return handleStaticCompound(
5619 node, field, operator, arg, isPrefix: true); 7836 node,
5620 } 7837 field, CompoundGetter.FIELD,
5621 7838 field, CompoundSetter.FIELD,
5622 @override 7839 new IncDecCompound(CompoundKind.PREFIX, operator),
5623 R visitStaticFieldSet( 7840 arg);
5624 SendSet node, 7841 }
5625 FieldElement field, 7842
5626 Node rhs, 7843 @override
5627 A arg) { 7844 R visitStaticGetterSetterPrefix(
5628 return handleStaticFieldSet(node, field, rhs, arg);
5629 }
5630
5631 @override
5632 R visitStaticFunctionGet(
5633 Send node,
5634 MethodElement function,
5635 A arg) {
5636 return handleStaticFunctionGet(node, function, arg);
5637 }
5638
5639 @override
5640 R visitStaticFunctionInvoke(
5641 Send node,
5642 MethodElement function,
5643 NodeList arguments,
5644 CallStructure callStructure,
5645 A arg) {
5646 return handleStaticFunctionInvoke(
5647 node, function, arguments, callStructure, arg);
5648 }
5649
5650 @override
5651 R visitStaticFunctionIncompatibleInvoke(
5652 Send node,
5653 MethodElement function,
5654 NodeList arguments,
5655 CallStructure callStructure,
5656 A arg) {
5657 return handleStaticFunctionIncompatibleInvoke(
5658 node, function, arguments, callStructure, arg);
5659 }
5660
5661 @override
5662 R visitStaticGetterGet(
5663 Send node, 7845 Send node,
5664 FunctionElement getter, 7846 FunctionElement getter,
5665 A arg) { 7847 FunctionElement setter,
5666 return handleStaticGetterGet(node, getter, arg); 7848 IncDecOperator operator,
5667 } 7849 A arg) {
5668 7850 return handleStaticCompound(
5669 @override 7851 node,
5670 R visitStaticGetterInvoke( 7852 getter, CompoundGetter.GETTER,
7853 setter, CompoundSetter.SETTER,
7854 new IncDecCompound(CompoundKind.PREFIX, operator),
7855 arg);
7856 }
7857
7858
7859 R visitStaticMethodSetterPrefix(
5671 Send node, 7860 Send node,
5672 FunctionElement getter, 7861 FunctionElement getter,
5673 NodeList arguments, 7862 FunctionElement setter,
5674 CallStructure callStructure, 7863 IncDecOperator operator,
5675 A arg) { 7864 A arg) {
5676 return handleStaticGetterInvoke( 7865 return handleStaticCompound(
5677 node, getter, arguments, callStructure, arg); 7866 node,
5678 } 7867 getter, CompoundGetter.METHOD,
5679 7868 setter, CompoundSetter.SETTER,
5680 @override 7869 new IncDecCompound(CompoundKind.PREFIX, operator),
5681 R visitStaticGetterSetterCompound( 7870 arg);
7871 }
7872
7873 @override
7874 R visitTopLevelFieldPrefix(
7875 Send node,
7876 FieldElement field,
7877 IncDecOperator operator,
7878 A arg) {
7879 return handleStaticCompound(
7880 node,
7881 field, CompoundGetter.FIELD,
7882 field, CompoundSetter.FIELD,
7883 new IncDecCompound(CompoundKind.PREFIX, operator),
7884 arg);
7885 }
7886
7887 @override
7888 R visitTopLevelGetterSetterPrefix(
5682 Send node, 7889 Send node,
5683 FunctionElement getter, 7890 FunctionElement getter,
5684 FunctionElement setter, 7891 FunctionElement setter,
7892 IncDecOperator operator,
7893 A arg) {
7894 return handleStaticCompound(
7895 node,
7896 getter, CompoundGetter.GETTER,
7897 setter, CompoundSetter.SETTER,
7898 new IncDecCompound(CompoundKind.PREFIX, operator),
7899 arg);
7900 }
7901
7902 @override
7903 R visitTopLevelMethodSetterPrefix(
7904 Send node,
7905 FunctionElement method,
7906 FunctionElement setter,
7907 IncDecOperator operator,
7908 A arg) {
7909 return handleStaticCompound(
7910 node,
7911 method, CompoundGetter.METHOD,
7912 setter, CompoundSetter.SETTER,
7913 new IncDecCompound(CompoundKind.PREFIX, operator),
7914 arg);
7915 }
7916
7917 @override
7918 R visitSuperFieldPrefix(
7919 Send node,
7920 FieldElement field,
7921 IncDecOperator operator,
7922 A arg) {
7923 return handleSuperCompound(
7924 node,
7925 field, CompoundGetter.FIELD,
7926 field, CompoundSetter.FIELD,
7927 new IncDecCompound(CompoundKind.PREFIX, operator),
7928 arg);
7929 }
7930
7931 @override
7932 R visitSuperFieldFieldPrefix(
7933 Send node,
7934 FieldElement readField,
7935 FieldElement writtenField,
7936 IncDecOperator operator,
7937 A arg) {
7938 return handleSuperCompound(
7939 node,
7940 readField, CompoundGetter.FIELD,
7941 writtenField, CompoundSetter.FIELD,
7942 new IncDecCompound(CompoundKind.PREFIX, operator),
7943 arg);
7944 }
7945
7946 @override
7947 R visitSuperFieldSetterPrefix(
7948 Send node,
7949 FieldElement field,
7950 FunctionElement setter,
7951 IncDecOperator operator,
7952 A arg) {
7953 return handleSuperCompound(
7954 node,
7955 field, CompoundGetter.FIELD,
7956 setter, CompoundSetter.SETTER,
7957 new IncDecCompound(CompoundKind.PREFIX, operator),
7958 arg);
7959 }
7960
7961
7962 R visitSuperGetterSetterPrefix(
7963 Send node,
7964 FunctionElement getter,
7965 FunctionElement setter,
7966 IncDecOperator operator,
7967 A arg) {
7968 return handleSuperCompound(
7969 node,
7970 getter, CompoundGetter.GETTER,
7971 setter, CompoundSetter.SETTER,
7972 new IncDecCompound(CompoundKind.PREFIX, operator),
7973 arg);
7974 }
7975
7976 @override
7977 R visitSuperGetterFieldPrefix(
7978 Send node,
7979 FunctionElement getter,
7980 FieldElement field,
7981 IncDecOperator operator,
7982 A arg) {
7983 return handleSuperCompound(
7984 node,
7985 getter, CompoundGetter.GETTER,
7986 field, CompoundSetter.FIELD,
7987 new IncDecCompound(CompoundKind.PREFIX, operator),
7988 arg);
7989 }
7990
7991 @override
7992 R visitSuperMethodSetterPrefix(
7993 Send node,
7994 FunctionElement method,
7995 FunctionElement setter,
7996 IncDecOperator operator,
7997 A arg) {
7998 return handleSuperCompound(
7999 node,
8000 method, CompoundGetter.METHOD,
8001 setter, CompoundSetter.SETTER,
8002 new IncDecCompound(CompoundKind.PREFIX, operator),
8003 arg);
8004 }
8005
8006 @override
8007 R visitClassTypeLiteralPrefix(
8008 Send node,
8009 ConstantExpression constant,
8010 IncDecOperator operator,
8011 A arg) {
8012 return handleConstantCompound(
8013 node,
8014 constant,
8015 new IncDecCompound(CompoundKind.PREFIX, operator),
8016 arg);
8017 }
8018
8019 @override
8020 R visitTypedefTypeLiteralPrefix(
8021 Send node,
8022 ConstantExpression constant,
8023 IncDecOperator operator,
8024 A arg) {
8025 return handleConstantCompound(
8026 node,
8027 constant,
8028 new IncDecCompound(CompoundKind.PREFIX, operator),
8029 arg);
8030 }
8031
8032 @override
8033 R visitTypeVariableTypeLiteralPrefix(
8034 Send node,
8035 TypeVariableElement element,
8036 IncDecOperator operator,
8037 A arg) {
8038 return handleTypeVariableTypeLiteralCompound(
8039 node,
8040 element,
8041 new IncDecCompound(CompoundKind.PREFIX, operator),
8042 arg);
8043 }
8044
8045 @override
8046 R visitDynamicTypeLiteralPrefix(
8047 Send node,
8048 ConstantExpression constant,
8049 IncDecOperator operator,
8050 A arg) {
8051 return handleConstantCompound(
8052 node,
8053 constant,
8054 new IncDecCompound(CompoundKind.PREFIX, operator),
8055 arg);
8056 }
8057
8058 @override
8059 R visitDynamicPropertyPostfix(
8060 Send node,
8061 Node receiver,
8062 IncDecOperator operator,
8063 Selector getterSelector,
8064 Selector setterSelector,
8065 A arg) {
8066 return handleDynamicCompound(
8067 node,
8068 receiver,
8069 new IncDecCompound(CompoundKind.POSTFIX, operator),
8070 getterSelector,
8071 setterSelector,
8072 arg);
8073 }
8074
8075 @override
8076 R visitParameterPostfix(
8077 Send node,
8078 ParameterElement parameter,
8079 IncDecOperator operator,
8080 A arg) {
8081 return handleLocalCompound(
8082 node,
8083 parameter,
8084 new IncDecCompound(CompoundKind.POSTFIX, operator),
8085 arg,
8086 isSetterValid: true);
8087 }
8088
8089 @override
8090 R visitLocalVariablePostfix(
8091 Send node,
8092 LocalVariableElement variable,
8093 IncDecOperator operator,
8094 A arg) {
8095 return handleLocalCompound(
8096 node,
8097 variable,
8098 new IncDecCompound(CompoundKind.POSTFIX, operator),
8099 arg,
8100 isSetterValid: true);
8101 }
8102
8103 @override
8104 R visitLocalFunctionPostfix(
8105 Send node,
8106 LocalFunctionElement function,
8107 IncDecOperator operator,
8108 A arg) {
8109 return handleLocalCompound(
8110 node,
8111 function,
8112 new IncDecCompound(CompoundKind.POSTFIX, operator),
8113 arg,
8114 isSetterValid: false);
8115 }
8116
8117
8118 R visitThisPropertyPostfix(
8119 Send node,
8120 IncDecOperator operator,
8121 Selector getterSelector,
8122 Selector setterSelector,
8123 A arg) {
8124 return handleDynamicCompound(
8125 node,
8126 null,
8127 new IncDecCompound(CompoundKind.POSTFIX, operator),
8128 getterSelector,
8129 setterSelector,
8130 arg);
8131 }
8132
8133 @override
8134 R visitStaticFieldPostfix(
8135 Send node,
8136 FieldElement field,
8137 IncDecOperator operator,
8138 A arg) {
8139 return handleStaticCompound(
8140 node,
8141 field, CompoundGetter.FIELD,
8142 field, CompoundSetter.FIELD,
8143 new IncDecCompound(CompoundKind.POSTFIX, operator),
8144 arg);
8145 }
8146
8147 @override
8148 R visitStaticGetterSetterPostfix(
8149 Send node,
8150 FunctionElement getter,
8151 FunctionElement setter,
8152 IncDecOperator operator,
8153 A arg) {
8154 return handleStaticCompound(
8155 node,
8156 getter, CompoundGetter.GETTER,
8157 setter, CompoundSetter.SETTER,
8158 new IncDecCompound(CompoundKind.POSTFIX, operator),
8159 arg);
8160 }
8161
8162
8163 R visitStaticMethodSetterPostfix(
8164 Send node,
8165 FunctionElement getter,
8166 FunctionElement setter,
8167 IncDecOperator operator,
8168 A arg) {
8169 return handleStaticCompound(
8170 node,
8171 getter, CompoundGetter.METHOD,
8172 setter, CompoundSetter.SETTER,
8173 new IncDecCompound(CompoundKind.POSTFIX, operator),
8174 arg);
8175 }
8176
8177 @override
8178 R visitTopLevelFieldPostfix(
8179 Send node,
8180 FieldElement field,
8181 IncDecOperator operator,
8182 A arg) {
8183 return handleStaticCompound(
8184 node,
8185 field, CompoundGetter.FIELD,
8186 field, CompoundSetter.FIELD,
8187 new IncDecCompound(CompoundKind.POSTFIX, operator),
8188 arg);
8189 }
8190
8191 @override
8192 R visitTopLevelGetterSetterPostfix(
8193 Send node,
8194 FunctionElement getter,
8195 FunctionElement setter,
8196 IncDecOperator operator,
8197 A arg) {
8198 return handleStaticCompound(
8199 node,
8200 getter, CompoundGetter.GETTER,
8201 setter, CompoundSetter.SETTER,
8202 new IncDecCompound(CompoundKind.POSTFIX, operator),
8203 arg);
8204 }
8205
8206 @override
8207 R visitTopLevelMethodSetterPostfix(
8208 Send node,
8209 FunctionElement method,
8210 FunctionElement setter,
8211 IncDecOperator operator,
8212 A arg) {
8213 return handleStaticCompound(
8214 node,
8215 method, CompoundGetter.METHOD,
8216 setter, CompoundSetter.SETTER,
8217 new IncDecCompound(CompoundKind.POSTFIX, operator),
8218 arg);
8219 }
8220
8221 @override
8222 R visitSuperFieldPostfix(
8223 Send node,
8224 FieldElement field,
8225 IncDecOperator operator,
8226 A arg) {
8227 return handleSuperCompound(
8228 node,
8229 field, CompoundGetter.FIELD,
8230 field, CompoundSetter.FIELD,
8231 new IncDecCompound(CompoundKind.POSTFIX, operator),
8232 arg);
8233 }
8234
8235 @override
8236 R visitSuperFieldFieldPostfix(
8237 Send node,
8238 FieldElement readField,
8239 FieldElement writtenField,
8240 IncDecOperator operator,
8241 A arg) {
8242 return handleSuperCompound(
8243 node,
8244 readField, CompoundGetter.FIELD,
8245 writtenField, CompoundSetter.FIELD,
8246 new IncDecCompound(CompoundKind.POSTFIX, operator),
8247 arg);
8248 }
8249
8250 @override
8251 R visitSuperFieldSetterPostfix(
8252 Send node,
8253 FieldElement field,
8254 FunctionElement setter,
8255 IncDecOperator operator,
8256 A arg) {
8257 return handleSuperCompound(
8258 node,
8259 field, CompoundGetter.FIELD,
8260 setter, CompoundSetter.SETTER,
8261 new IncDecCompound(CompoundKind.POSTFIX, operator),
8262 arg);
8263 }
8264
8265
8266 R visitSuperGetterSetterPostfix(
8267 Send node,
8268 FunctionElement getter,
8269 FunctionElement setter,
8270 IncDecOperator operator,
8271 A arg) {
8272 return handleSuperCompound(
8273 node,
8274 getter, CompoundGetter.GETTER,
8275 setter, CompoundSetter.SETTER,
8276 new IncDecCompound(CompoundKind.POSTFIX, operator),
8277 arg);
8278 }
8279
8280 @override
8281 R visitSuperGetterFieldPostfix(
8282 Send node,
8283 FunctionElement getter,
8284 FieldElement field,
8285 IncDecOperator operator,
8286 A arg) {
8287 return handleSuperCompound(
8288 node,
8289 getter, CompoundGetter.GETTER,
8290 field, CompoundSetter.FIELD,
8291 new IncDecCompound(CompoundKind.POSTFIX, operator),
8292 arg);
8293 }
8294
8295 @override
8296 R visitSuperMethodSetterPostfix(
8297 Send node,
8298 FunctionElement method,
8299 FunctionElement setter,
8300 IncDecOperator operator,
8301 A arg) {
8302 return handleSuperCompound(
8303 node,
8304 method, CompoundGetter.METHOD,
8305 setter, CompoundSetter.SETTER,
8306 new IncDecCompound(CompoundKind.POSTFIX, operator),
8307 arg);
8308 }
8309
8310 @override
8311 R visitClassTypeLiteralPostfix(
8312 Send node,
8313 ConstantExpression constant,
8314 IncDecOperator operator,
8315 A arg) {
8316 return handleConstantCompound(
8317 node,
8318 constant,
8319 new IncDecCompound(CompoundKind.POSTFIX, operator),
8320 arg);
8321 }
8322
8323 @override
8324 R visitTypedefTypeLiteralPostfix(
8325 Send node,
8326 ConstantExpression constant,
8327 IncDecOperator operator,
8328 A arg) {
8329 return handleConstantCompound(
8330 node,
8331 constant,
8332 new IncDecCompound(CompoundKind.POSTFIX, operator),
8333 arg);
8334 }
8335
8336 @override
8337 R visitTypeVariableTypeLiteralPostfix(
8338 Send node,
8339 TypeVariableElement element,
8340 IncDecOperator operator,
8341 A arg) {
8342 return handleTypeVariableTypeLiteralCompound(
8343 node,
8344 element,
8345 new IncDecCompound(CompoundKind.POSTFIX, operator),
8346 arg);
8347 }
8348
8349 @override
8350 R visitDynamicTypeLiteralPostfix(
8351 Send node,
8352 ConstantExpression constant,
8353 IncDecOperator operator,
8354 A arg) {
8355 return handleConstantCompound(
8356 node,
8357 constant,
8358 new IncDecCompound(CompoundKind.POSTFIX, operator),
8359 arg);
8360 }
8361
8362 @override
8363 R visitUnresolvedStaticGetterPostfix(
8364 Send node,
8365 Element element,
8366 MethodElement setter,
8367 IncDecOperator operator,
8368 A arg) {
8369 return handleStaticCompound(
8370 node,
8371 element,
8372 CompoundGetter.UNRESOLVED,
8373 setter,
8374 CompoundSetter.SETTER,
8375 new IncDecCompound(CompoundKind.POSTFIX, operator),
8376 arg);
8377 }
8378
8379 @override
8380 R visitUnresolvedTopLevelGetterPostfix(
8381 Send node,
8382 Element element,
8383 MethodElement setter,
8384 IncDecOperator operator,
8385 A arg) {
8386 return handleStaticCompound(
8387 node,
8388 element,
8389 CompoundGetter.UNRESOLVED,
8390 setter,
8391 CompoundSetter.SETTER,
8392 new IncDecCompound(CompoundKind.POSTFIX, operator),
8393 arg);
8394 }
8395
8396 @override
8397 R visitUnresolvedStaticSetterPostfix(
8398 Send node,
8399 MethodElement getter,
8400 Element element,
8401 IncDecOperator operator,
8402 A arg) {
8403 return handleStaticCompound(
8404 node,
8405 getter,
8406 CompoundGetter.GETTER,
8407 element,
8408 CompoundSetter.INVALID,
8409 new IncDecCompound(CompoundKind.POSTFIX, operator),
8410 arg);
8411 }
8412
8413 @override
8414 R visitUnresolvedTopLevelSetterPostfix(
8415 Send node,
8416 MethodElement getter,
8417 Element element,
8418 IncDecOperator operator,
8419 A arg) {
8420 return handleStaticCompound(
8421 node,
8422 getter,
8423 CompoundGetter.GETTER,
8424 element,
8425 CompoundSetter.INVALID,
8426 new IncDecCompound(CompoundKind.POSTFIX, operator),
8427 arg);
8428 }
8429
8430 @override
8431 R visitStaticMethodPostfix(
8432 Send node,
8433 MethodElement method,
8434 IncDecOperator operator,
8435 A arg) {
8436 return handleStaticCompound(
8437 node,
8438 method,
8439 CompoundGetter.METHOD,
8440 method,
8441 CompoundSetter.INVALID,
8442 new IncDecCompound(CompoundKind.POSTFIX, operator),
8443 arg);
8444 }
8445
8446 @override
8447 R visitTopLevelMethodPostfix(
8448 Send node,
8449 MethodElement method,
8450 IncDecOperator operator,
8451 A arg) {
8452 return handleStaticCompound(
8453 node,
8454 method,
8455 CompoundGetter.METHOD,
8456 method,
8457 CompoundSetter.INVALID,
8458 new IncDecCompound(CompoundKind.POSTFIX, operator),
8459 arg);
8460 }
8461
8462 @override
8463 R visitUnresolvedPostfix(
8464 Send node,
8465 Element element,
8466 IncDecOperator operator,
8467 A arg) {
8468 return handleStaticCompound(
8469 node,
8470 element,
8471 CompoundGetter.UNRESOLVED,
8472 element,
8473 CompoundSetter.INVALID,
8474 new IncDecCompound(CompoundKind.POSTFIX, operator),
8475 arg);
8476 }
8477
8478 @override
8479 R visitUnresolvedStaticGetterPrefix(
8480 Send node,
8481 Element element,
8482 MethodElement setter,
8483 IncDecOperator operator,
8484 A arg) {
8485 return handleStaticCompound(
8486 node,
8487 element,
8488 CompoundGetter.UNRESOLVED,
8489 setter,
8490 CompoundSetter.SETTER,
8491 new IncDecCompound(CompoundKind.PREFIX, operator),
8492 arg);
8493 }
8494
8495 @override
8496 R visitUnresolvedTopLevelGetterPrefix(
8497 Send node,
8498 Element element,
8499 MethodElement setter,
8500 IncDecOperator operator,
8501 A arg) {
8502 return handleStaticCompound(
8503 node,
8504 element,
8505 CompoundGetter.UNRESOLVED,
8506 setter,
8507 CompoundSetter.SETTER,
8508 new IncDecCompound(CompoundKind.PREFIX, operator),
8509 arg);
8510 }
8511
8512 @override
8513 R visitUnresolvedStaticSetterPrefix(
8514 Send node,
8515 MethodElement getter,
8516 Element element,
8517 IncDecOperator operator,
8518 A arg) {
8519 return handleStaticCompound(
8520 node,
8521 getter,
8522 CompoundGetter.GETTER,
8523 element,
8524 CompoundSetter.INVALID,
8525 new IncDecCompound(CompoundKind.PREFIX, operator),
8526 arg);
8527 }
8528
8529 @override
8530 R visitUnresolvedTopLevelSetterPrefix(
8531 Send node,
8532 MethodElement getter,
8533 Element element,
8534 IncDecOperator operator,
8535 A arg) {
8536 return handleStaticCompound(
8537 node,
8538 getter,
8539 CompoundGetter.GETTER,
8540 element,
8541 CompoundSetter.INVALID,
8542 new IncDecCompound(CompoundKind.PREFIX, operator),
8543 arg);
8544 }
8545
8546 @override
8547 R visitStaticMethodPrefix(
8548 Send node,
8549 MethodElement method,
8550 IncDecOperator operator,
8551 A arg) {
8552 return handleStaticCompound(
8553 node,
8554 method,
8555 CompoundGetter.METHOD,
8556 method,
8557 CompoundSetter.INVALID,
8558 new IncDecCompound(CompoundKind.PREFIX, operator),
8559 arg);
8560 }
8561
8562 @override
8563 R visitTopLevelMethodPrefix(
8564 Send node,
8565 MethodElement method,
8566 IncDecOperator operator,
8567 A arg) {
8568 return handleStaticCompound(
8569 node,
8570 method,
8571 CompoundGetter.METHOD,
8572 method,
8573 CompoundSetter.INVALID,
8574 new IncDecCompound(CompoundKind.PREFIX, operator),
8575 arg);
8576 }
8577
8578 @override
8579 R visitUnresolvedPrefix(
8580 Send node,
8581 Element element,
8582 IncDecOperator operator,
8583 A arg) {
8584 return handleStaticCompound(
8585 node,
8586 element,
8587 CompoundGetter.UNRESOLVED,
8588 element,
8589 CompoundSetter.INVALID,
8590 new IncDecCompound(CompoundKind.PREFIX, operator),
8591 arg);
8592 }
8593
8594 @override
8595 R visitUnresolvedStaticGetterCompound(
8596 Send node,
8597 Element element,
8598 MethodElement setter,
5685 AssignmentOperator operator, 8599 AssignmentOperator operator,
5686 Node rhs, 8600 Node rhs,
5687 A arg) { 8601 A arg) {
5688 return handleStaticGetterSetterCompound( 8602 return handleStaticCompound(
5689 node, getter, setter, operator, rhs, arg); 8603 node,
5690 } 8604 element,
5691 8605 CompoundGetter.UNRESOLVED,
5692 @override 8606 setter,
5693 R visitStaticGetterSetterPostfix( 8607 CompoundSetter.SETTER,
5694 Send node, 8608 new AssignmentCompound(operator, rhs),
5695 FunctionElement getter, 8609 arg);
5696 FunctionElement setter, 8610 }
5697 IncDecOperator operator, 8611
5698 A arg) { 8612 @override
5699 return handleStaticGetterSetterPostfixPrefix( 8613 R visitUnresolvedTopLevelGetterCompound(
5700 node, getter, setter, operator, arg, isPrefix: false); 8614 Send node,
5701 } 8615 Element element,
5702 8616 MethodElement setter,
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, 8617 AssignmentOperator operator,
5720 Node rhs, 8618 Node rhs,
5721 A arg) { 8619 A arg) {
5722 return handleStaticMethodSetterCompound( 8620 return handleStaticCompound(
5723 node, method, setter, operator, rhs, arg); 8621 node,
5724 } 8622 element,
5725 8623 CompoundGetter.UNRESOLVED,
5726 @override 8624 setter,
5727 R visitStaticMethodSetterPostfix( 8625 CompoundSetter.SETTER,
5728 Send node, 8626 new AssignmentCompound(operator, rhs),
5729 FunctionElement getter, 8627 arg);
5730 FunctionElement setter, 8628 }
5731 IncDecOperator operator, 8629
5732 A arg) { 8630 @override
5733 return handleStaticMethodSetterPostfixPrefix( 8631 R visitUnresolvedStaticSetterCompound(
5734 node, getter, setter, operator, arg, isPrefix: false); 8632 Send node,
5735 } 8633 MethodElement getter,
5736 8634 Element element,
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(
5750 SendSet node,
5751 FunctionElement setter,
5752 Node rhs,
5753 A arg) {
5754 return handleStaticSetterSet(node, setter, rhs, arg);
5755 }
5756
5757 @override
5758 R visitTopLevelFieldCompound(
5759 Send node,
5760 FieldElement field,
5761 AssignmentOperator operator, 8635 AssignmentOperator operator,
5762 Node rhs, 8636 Node rhs,
5763 A arg) { 8637 A arg) {
5764 return handleStaticFieldCompound(node, field, operator, rhs, arg); 8638 return handleStaticCompound(
5765 } 8639 node,
5766 8640 getter,
5767 @override 8641 CompoundGetter.GETTER,
5768 R visitTopLevelFieldGet( 8642 element,
5769 Send node, 8643 CompoundSetter.INVALID,
5770 FieldElement field, 8644 new AssignmentCompound(operator, rhs),
5771 A arg) { 8645 arg);
5772 return handleStaticFieldGet(node, field, arg); 8646 }
5773 } 8647
5774 8648 @override
5775 @override 8649 R visitUnresolvedTopLevelSetterCompound(
5776 R visitTopLevelFieldInvoke( 8650 Send node,
5777 Send node, 8651 MethodElement getter,
5778 FieldElement field, 8652 Element element,
5779 NodeList arguments,
5780 CallStructure callStructure,
5781 A arg) {
5782 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
5783 }
5784
5785 @override
5786 R visitTopLevelFieldPostfix(
5787 Send node,
5788 FieldElement field,
5789 IncDecOperator operator,
5790 A arg) {
5791 return handleStaticFieldPostfixPrefix(
5792 node, field, operator, arg, isPrefix: false);
5793 }
5794
5795 @override
5796 R visitTopLevelFieldPrefix(
5797 Send node,
5798 FieldElement field,
5799 IncDecOperator operator,
5800 A arg) {
5801 return handleStaticFieldPostfixPrefix(
5802 node, field, operator, arg, isPrefix: true);
5803 }
5804
5805 @override
5806 R visitTopLevelFieldSet(
5807 SendSet node,
5808 FieldElement field,
5809 Node rhs,
5810 A arg) {
5811 return handleStaticFieldSet(node, field, rhs, arg);
5812 }
5813
5814 @override
5815 R visitTopLevelFunctionGet(
5816 Send node,
5817 MethodElement function,
5818 A arg) {
5819 return handleStaticFunctionGet(node, function, arg);
5820 }
5821
5822 @override
5823 R visitTopLevelFunctionInvoke(
5824 Send node,
5825 MethodElement function,
5826 NodeList arguments,
5827 CallStructure callStructure,
5828 A arg) {
5829 return handleStaticFunctionInvoke(
5830 node, function, arguments, callStructure, arg);
5831 }
5832
5833 @override
5834 R visitTopLevelFunctionIncompatibleInvoke(
5835 Send node,
5836 MethodElement function,
5837 NodeList arguments,
5838 CallStructure callStructure,
5839 A arg) {
5840 return handleStaticFunctionIncompatibleInvoke(
5841 node, function, arguments, callStructure, arg);
5842 }
5843
5844 @override
5845 R visitTopLevelGetterGet(
5846 Send node,
5847 FunctionElement getter,
5848 A arg) {
5849 return handleStaticGetterGet(node, getter, arg);
5850 }
5851
5852 @override
5853 R visitTopLevelGetterInvoke(
5854 Send node,
5855 FunctionElement getter,
5856 NodeList arguments,
5857 CallStructure callStructure,
5858 A arg) {
5859 return handleStaticGetterInvoke(
5860 node, getter, arguments, callStructure, arg);
5861 }
5862
5863 @override
5864 R visitTopLevelGetterSetterCompound(
5865 Send node,
5866 FunctionElement getter,
5867 FunctionElement setter,
5868 AssignmentOperator operator, 8653 AssignmentOperator operator,
5869 Node rhs, 8654 Node rhs,
5870 A arg) { 8655 A arg) {
5871 return handleStaticGetterSetterCompound( 8656 return handleStaticCompound(
5872 node, getter, setter, operator, rhs, arg); 8657 node,
5873 } 8658 getter,
5874 8659 CompoundGetter.GETTER,
5875 @override 8660 element,
5876 R visitTopLevelGetterSetterPostfix( 8661 CompoundSetter.INVALID,
5877 Send node, 8662 new AssignmentCompound(operator, rhs),
5878 FunctionElement getter, 8663 arg);
5879 FunctionElement setter, 8664 }
5880 IncDecOperator operator, 8665
5881 A arg) { 8666 @override
5882 return handleStaticGetterSetterPostfixPrefix( 8667 R visitStaticMethodCompound(
5883 node, getter, setter, operator, arg, isPrefix: false); 8668 Send node,
5884 } 8669 MethodElement method,
5885
5886 @override
5887 R visitTopLevelGetterSetterPrefix(
5888 Send node,
5889 FunctionElement getter,
5890 FunctionElement setter,
5891 IncDecOperator operator,
5892 A arg) {
5893 return handleStaticGetterSetterPostfixPrefix(
5894 node, getter, setter, operator, arg, isPrefix: true);
5895 }
5896
5897 @override
5898 R visitTopLevelMethodSetterCompound(
5899 Send node,
5900 FunctionElement method,
5901 FunctionElement setter,
5902 AssignmentOperator operator, 8670 AssignmentOperator operator,
5903 Node rhs, 8671 Node rhs,
5904 A arg) { 8672 A arg) {
5905 return handleStaticMethodSetterCompound( 8673 return handleStaticCompound(
5906 node, method, setter, operator, rhs, arg); 8674 node,
5907 } 8675 method,
5908 8676 CompoundGetter.METHOD,
5909 @override 8677 method,
5910 R visitTopLevelMethodSetterPostfix( 8678 CompoundSetter.INVALID,
5911 Send node, 8679 new AssignmentCompound(operator, rhs),
5912 FunctionElement method, 8680 arg);
5913 FunctionElement setter, 8681 }
5914 IncDecOperator operator, 8682
5915 A arg) { 8683 @override
5916 return handleStaticMethodSetterPostfixPrefix( 8684 R visitTopLevelMethodCompound(
5917 node, method, setter, operator, arg, isPrefix: false); 8685 Send node,
5918 } 8686 MethodElement method,
5919
5920 @override
5921 R visitTopLevelMethodSetterPrefix(
5922 Send node,
5923 FunctionElement method,
5924 FunctionElement setter,
5925 IncDecOperator operator,
5926 A arg) {
5927 return handleStaticMethodSetterPostfixPrefix(
5928 node, method, setter, operator, arg, isPrefix: true);
5929 }
5930
5931 @override
5932 R visitTopLevelSetterSet(
5933 SendSet node,
5934 FunctionElement setter,
5935 Node rhs,
5936 A arg) {
5937 return handleStaticSetterSet(node, setter, rhs, arg);
5938 }
5939 }
5940
5941 /// Mixin that groups all `visitLocalX` and `visitParameterX` method by
5942 /// delegating calls to `handleLocalX` methods.
5943 ///
5944 /// This mixin is useful for the cases where both parameters, local variables,
5945 /// and local functions, captured or not, are handled uniformly.
5946 abstract class BaseImplementationOfLocalsMixin<R, A>
5947 implements SemanticSendVisitor<R, A> {
5948 R handleLocalCompound(
5949 Send node,
5950 LocalElement element,
5951 AssignmentOperator operator, 8687 AssignmentOperator operator,
5952 Node rhs, 8688 Node rhs,
5953 A arg); 8689 A arg) {
5954 8690 return handleStaticCompound(
5955 R handleLocalGet( 8691 node,
5956 Send node, 8692 method,
5957 LocalElement element, 8693 CompoundGetter.METHOD,
5958 A arg); 8694 method,
5959 8695 CompoundSetter.INVALID,
5960 R handleLocalInvoke( 8696 new AssignmentCompound(operator, rhs),
5961 Send node, 8697 arg);
5962 LocalElement element, 8698 }
5963 NodeList arguments, 8699
5964 CallStructure callStructure, 8700 @override
5965 A arg); 8701 R visitUnresolvedCompound(
5966 8702 Send node,
5967 R handleLocalPostfixPrefix( 8703 Element element,
5968 Send node,
5969 LocalElement element,
5970 IncDecOperator operator,
5971 A arg,
5972 {bool isPrefix});
5973
5974 R handleLocalSet(
5975 SendSet node,
5976 LocalElement element,
5977 Node rhs,
5978 A arg);
5979
5980 @override
5981 R visitLocalFunctionGet(
5982 Send node,
5983 LocalFunctionElement function,
5984 A arg) {
5985 return handleLocalGet(node, function, arg);
5986 }
5987
5988 @override
5989 R visitLocalFunctionInvoke(
5990 Send node,
5991 LocalFunctionElement function,
5992 NodeList arguments,
5993 CallStructure callStructure,
5994 A arg) {
5995 return handleLocalInvoke(node, function, arguments, callStructure, arg);
5996 }
5997
5998 @override
5999 R visitLocalVariableCompound(
6000 Send node,
6001 LocalVariableElement variable,
6002 AssignmentOperator operator, 8704 AssignmentOperator operator,
6003 Node rhs, 8705 Node rhs,
6004 A arg) { 8706 A arg) {
6005 return handleLocalCompound(node, variable, operator, rhs, arg); 8707 return handleStaticCompound(
6006 } 8708 node,
6007 8709 element,
6008 @override 8710 CompoundGetter.UNRESOLVED,
6009 R visitLocalVariableGet( 8711 element,
8712 CompoundSetter.INVALID,
8713 new AssignmentCompound(operator, rhs),
8714 arg);
8715 }
8716
8717 @override
8718 R visitFinalLocalVariablePostfix(
6010 Send node, 8719 Send node,
6011 LocalVariableElement variable, 8720 LocalVariableElement variable,
6012 A arg) { 8721 IncDecOperator operator,
6013 return handleLocalGet(node, variable, arg); 8722 A arg) {
6014 } 8723 return handleLocalCompound(
6015 8724 node,
6016 @override 8725 variable,
6017 R visitLocalVariableInvoke( 8726 new IncDecCompound(CompoundKind.POSTFIX, operator),
8727 arg,
8728 isSetterValid: false);
8729 }
8730
8731 @override
8732 R visitFinalLocalVariablePrefix(
6018 Send node, 8733 Send node,
6019 LocalVariableElement variable, 8734 LocalVariableElement variable,
6020 NodeList arguments, 8735 IncDecOperator operator,
6021 CallStructure callStructure, 8736 A arg) {
6022 A arg) { 8737 return handleLocalCompound(
6023 return handleLocalInvoke(node, variable, arguments, callStructure, arg); 8738 node,
6024 } 8739 variable,
6025 8740 new IncDecCompound(CompoundKind.PREFIX, operator),
6026 @override 8741 arg,
6027 R visitLocalVariablePostfix( 8742 isSetterValid: false);
6028 Send node, 8743 }
6029 LocalVariableElement variable, 8744
6030 IncDecOperator operator, 8745 @override
6031 A arg) { 8746 R visitFinalParameterPostfix(
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(
6048 SendSet node,
6049 LocalVariableElement variable,
6050 Node rhs,
6051 A arg) {
6052 return handleLocalSet(node, variable, rhs, arg);
6053 }
6054
6055 @override
6056 R visitParameterCompound(
6057 Send node, 8747 Send node,
6058 ParameterElement parameter, 8748 ParameterElement parameter,
8749 IncDecOperator operator,
8750 A arg) {
8751 return handleLocalCompound(
8752 node,
8753 parameter,
8754 new IncDecCompound(CompoundKind.POSTFIX, operator),
8755 arg,
8756 isSetterValid: false);
8757 }
8758
8759 @override
8760 R visitFinalParameterPrefix(
8761 Send node,
8762 ParameterElement parameter,
8763 IncDecOperator operator,
8764 A arg) {
8765 return handleLocalCompound(
8766 node,
8767 parameter,
8768 new IncDecCompound(CompoundKind.PREFIX, operator),
8769 arg,
8770 isSetterValid: false);
8771 }
8772
8773 @override
8774 R visitStaticFinalFieldPostfix(
8775 Send node,
8776 FieldElement field,
8777 IncDecOperator operator,
8778 A arg) {
8779 return handleStaticCompound(
8780 node,
8781 field,
8782 CompoundGetter.FIELD,
8783 field,
8784 CompoundSetter.INVALID,
8785 new IncDecCompound(CompoundKind.POSTFIX, operator),
8786 arg);
8787 }
8788
8789 @override
8790 R visitStaticFinalFieldPrefix(
8791 Send node,
8792 FieldElement field,
8793 IncDecOperator operator,
8794 A arg) {
8795 return handleStaticCompound(
8796 node,
8797 field,
8798 CompoundGetter.FIELD,
8799 field,
8800 CompoundSetter.INVALID,
8801 new IncDecCompound(CompoundKind.PREFIX, operator),
8802 arg);
8803 }
8804
8805 @override
8806 R visitSuperFieldFieldCompound(
8807 Send node,
8808 FieldElement readField,
8809 FieldElement writtenField,
6059 AssignmentOperator operator, 8810 AssignmentOperator operator,
6060 Node rhs, 8811 Node rhs,
6061 A arg) { 8812 A arg) {
6062 return handleLocalCompound(node, parameter, operator, rhs, arg); 8813 return handleSuperCompound(
6063 } 8814 node,
6064 8815 readField,
6065 @override 8816 CompoundGetter.FIELD,
6066 R visitParameterGet( 8817 writtenField,
6067 Send node, 8818 CompoundSetter.FIELD,
6068 ParameterElement parameter, 8819 new AssignmentCompound(operator, rhs),
6069 A arg) { 8820 arg);
6070 return handleLocalGet(node, parameter, arg); 8821 }
6071 } 8822
6072 8823 @override
6073 @override 8824 R visitSuperFinalFieldPostfix(
6074 R visitParameterInvoke( 8825 Send node,
6075 Send node, 8826 FieldElement field,
6076 ParameterElement parameter, 8827 IncDecOperator operator,
6077 NodeList arguments, 8828 A arg) {
6078 CallStructure callStructure, 8829 return handleSuperCompound(
6079 A arg) { 8830 node,
6080 return handleLocalInvoke(node, parameter, arguments, callStructure, arg); 8831 field,
6081 } 8832 CompoundGetter.FIELD,
6082 8833 field,
6083 @override 8834 CompoundSetter.INVALID,
6084 R visitParameterPostfix( 8835 new IncDecCompound(CompoundKind.POSTFIX, operator),
6085 Send node, 8836 arg);
6086 ParameterElement parameter, 8837 }
6087 IncDecOperator operator, 8838
6088 A arg) { 8839 @override
6089 return handleLocalPostfixPrefix( 8840 R visitSuperFinalFieldPrefix(
6090 node, parameter, operator, arg, isPrefix: false); 8841 Send node,
6091 } 8842 FieldElement field,
6092 8843 IncDecOperator operator,
6093 @override 8844 A arg) {
6094 R visitParameterPrefix( 8845 return handleSuperCompound(
6095 Send node, 8846 node,
6096 ParameterElement parameter, 8847 field,
6097 IncDecOperator operator, 8848 CompoundGetter.FIELD,
6098 A arg) { 8849 field,
6099 return handleLocalPostfixPrefix( 8850 CompoundSetter.INVALID,
6100 node, parameter, operator, arg, isPrefix: true); 8851 new IncDecCompound(CompoundKind.PREFIX, operator),
6101 } 8852 arg);
6102 8853 }
6103 @override 8854
6104 R visitParameterSet( 8855 @override
6105 SendSet node, 8856 R visitSuperMethodCompound(
6106 ParameterElement parameter, 8857 Send node,
6107 Node rhs, 8858 FunctionElement method,
6108 A arg) {
6109 return handleLocalSet(node, parameter, rhs, arg);
6110 }
6111 }
6112
6113 /// Mixin that groups all `visitConstantX` and `visitXTypeLiteralY` methods for
6114 /// constant type literals by delegating calls to `handleConstantX` methods.
6115 ///
6116 /// This mixin is useful for the cases where expressions on constants are
6117 /// handled uniformly.
6118 abstract class BaseImplementationOfConstantsMixin<R, A>
6119 implements SemanticSendVisitor<R, A> {
6120 R handleConstantGet(
6121 Node node,
6122 ConstantExpression constant,
6123 A arg);
6124
6125 R handleConstantInvoke(
6126 Send node,
6127 ConstantExpression constant,
6128 NodeList arguments,
6129 CallStructure callStructure,
6130 A arg);
6131
6132 @override
6133 R visitClassTypeLiteralGet(
6134 Send node,
6135 ConstantExpression constant,
6136 A arg) {
6137 return handleConstantGet(node, constant, arg);
6138 }
6139
6140 @override
6141 R visitClassTypeLiteralInvoke(
6142 Send node,
6143 ConstantExpression constant,
6144 NodeList arguments,
6145 CallStructure callStructure,
6146 A arg) {
6147 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
6148 }
6149
6150 @override
6151 R visitConstConstructorInvoke(
6152 NewExpression node,
6153 ConstructedConstantExpression constant,
6154 A arg) {
6155 return handleConstantGet(node, constant, arg);
6156 }
6157
6158 @override
6159 R visitConstantGet(
6160 Send node,
6161 ConstantExpression constant,
6162 A arg) {
6163 return handleConstantGet(node, constant, arg);
6164 }
6165
6166 @override
6167 R visitConstantInvoke(
6168 Send node,
6169 ConstantExpression constant,
6170 NodeList arguments,
6171 CallStructure callStructure,
6172 A arg) {
6173 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
6174 }
6175
6176 @override
6177 R visitDynamicTypeLiteralGet(
6178 Send node,
6179 ConstantExpression constant,
6180 A arg) {
6181 return handleConstantGet(node, constant, arg);
6182 }
6183
6184 @override
6185 R visitDynamicTypeLiteralInvoke(
6186 Send node,
6187 ConstantExpression constant,
6188 NodeList arguments,
6189 CallStructure callStructure,
6190 A arg) {
6191 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
6192 }
6193
6194 @override
6195 R visitTypedefTypeLiteralGet(
6196 Send node,
6197 ConstantExpression constant,
6198 A arg) {
6199 return handleConstantGet(node, constant, arg);
6200 }
6201
6202 @override
6203 R visitTypedefTypeLiteralInvoke(
6204 Send node,
6205 ConstantExpression constant,
6206 NodeList arguments,
6207 CallStructure callStructure,
6208 A arg) {
6209 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
6210 }
6211 }
6212
6213 /// Mixin that groups all `visitDynamicPropertyX` and `visitThisPropertyY`
6214 /// methods for by delegating calls to `handleDynamicX` methods, providing
6215 /// `null` as the receiver for the this properties.
6216 ///
6217 /// This mixin is useful for the cases where dynamic and this properties are
6218 /// handled uniformly.
6219 abstract class BaseImplementationOfDynamicsMixin<R, A>
6220 implements SemanticSendVisitor<R, A> {
6221 R handleDynamicCompound(
6222 Send node,
6223 Node receiver,
6224 AssignmentOperator operator, 8859 AssignmentOperator operator,
6225 Node rhs, 8860 Node rhs,
6226 Selector getterSelector, 8861 A arg) {
6227 Selector setterSelector, 8862 return handleSuperCompound(
6228 A arg); 8863 node,
6229 8864 method,
6230 R handleDynamicGet( 8865 CompoundGetter.METHOD,
6231 Send node, 8866 method,
6232 Node receiver, 8867 CompoundSetter.INVALID,
6233 Selector selector, 8868 new AssignmentCompound(operator, rhs),
6234 A arg); 8869 arg);
6235 8870 }
6236 R handleDynamicInvoke( 8871
6237 Send node, 8872 @override
6238 Node receiver, 8873 R visitSuperMethodPostfix(
6239 NodeList arguments, 8874 Send node,
6240 Selector selector, 8875 FunctionElement method,
6241 A arg); 8876 IncDecOperator operator,
6242 8877 A arg) {
6243 R handleDynamicPostfixPrefix( 8878 return handleSuperCompound(
6244 Send node, 8879 node,
6245 Node receiver, 8880 method,
6246 IncDecOperator operator, 8881 CompoundGetter.METHOD,
6247 Selector getterSelector, 8882 method,
6248 Selector setterSelector, 8883 CompoundSetter.INVALID,
6249 A arg, 8884 new IncDecCompound(CompoundKind.POSTFIX, operator),
6250 {bool isPrefix}); 8885 arg);
6251 8886 }
6252 R handleDynamicSet( 8887
6253 SendSet node, 8888 @override
6254 Node receiver, 8889 R visitSuperMethodPrefix(
6255 Selector selector, 8890 Send node,
6256 Node rhs, 8891 FunctionElement method,
6257 A arg); 8892 IncDecOperator operator,
6258 8893 A arg) {
6259 R handleDynamicIndexPostfixPrefix( 8894 return handleSuperCompound(
6260 Send node, 8895 node,
6261 Node receiver, 8896 method,
6262 Node index, 8897 CompoundGetter.METHOD,
6263 IncDecOperator operator, 8898 method,
6264 A arg, 8899 CompoundSetter.INVALID,
6265 {bool isPrefix}); 8900 new IncDecCompound(CompoundKind.PREFIX, operator),
6266 8901 arg);
6267 @override 8902 }
6268 R visitDynamicPropertyCompound( 8903
6269 Send node, 8904 @override
6270 Node receiver, 8905 R visitTopLevelFinalFieldPostfix(
8906 Send node,
8907 FieldElement field,
8908 IncDecOperator operator,
8909 A arg) {
8910 return handleStaticCompound(
8911 node,
8912 field,
8913 CompoundGetter.FIELD,
8914 field,
8915 CompoundSetter.INVALID,
8916 new IncDecCompound(CompoundKind.POSTFIX, operator),
8917 arg);
8918 }
8919
8920 @override
8921 R visitTopLevelFinalFieldPrefix(
8922 Send node,
8923 FieldElement field,
8924 IncDecOperator operator,
8925 A arg) {
8926 return handleStaticCompound(
8927 node,
8928 field,
8929 CompoundGetter.FIELD,
8930 field,
8931 CompoundSetter.INVALID,
8932 new IncDecCompound(CompoundKind.PREFIX, operator),
8933 arg);
8934 }
8935
8936 @override
8937 R visitUnresolvedSuperCompound(
8938 Send node,
8939 Element element,
6271 AssignmentOperator operator, 8940 AssignmentOperator operator,
6272 Node rhs, 8941 Node rhs,
6273 Selector getterSelector, 8942 A arg) {
6274 Selector setterSelector, 8943 return handleSuperCompound(
6275 A arg) { 8944 node,
6276 return handleDynamicCompound( 8945 element,
6277 node, receiver, operator, rhs, getterSelector, setterSelector, arg); 8946 CompoundGetter.UNRESOLVED,
6278 } 8947 element,
6279 8948 CompoundSetter.INVALID,
6280 @override 8949 new AssignmentCompound(operator, rhs),
6281 R visitDynamicPropertyGet( 8950 arg);
6282 Send node, 8951 }
6283 Node receiver, 8952
6284 Selector selector, 8953 @override
6285 A arg) { 8954 R visitUnresolvedSuperPostfix(
6286 return handleDynamicGet(node, receiver, selector, arg); 8955 Send node,
6287 } 8956 Element element,
6288 8957 IncDecOperator operator,
6289 @override 8958 A arg) {
6290 R visitDynamicPropertyInvoke( 8959 return handleSuperCompound(
6291 Send node, 8960 node,
6292 Node receiver, 8961 element,
6293 NodeList arguments, 8962 CompoundGetter.UNRESOLVED,
6294 Selector selector, 8963 element,
6295 A arg) { 8964 CompoundSetter.INVALID,
6296 return handleDynamicInvoke(node, receiver, arguments, selector, arg); 8965 new IncDecCompound(CompoundKind.POSTFIX, operator),
6297 } 8966 arg);
6298 8967 }
6299 @override 8968
6300 R visitDynamicPropertyPostfix( 8969 @override
6301 Send node, 8970 R visitUnresolvedSuperPrefix(
6302 Node receiver, 8971 Send node,
6303 IncDecOperator operator, 8972 Element element,
6304 Selector getterSelector, 8973 IncDecOperator operator,
6305 Selector setterSelector, 8974 A arg) {
6306 A arg) { 8975 return handleSuperCompound(
6307 return handleDynamicPostfixPrefix( 8976 node,
6308 node, receiver, operator, 8977 element,
6309 getterSelector, setterSelector, arg, isPrefix: false); 8978 CompoundGetter.UNRESOLVED,
6310 } 8979 element,
6311 8980 CompoundSetter.INVALID,
6312 @override 8981 new IncDecCompound(CompoundKind.PREFIX, operator),
6313 R visitDynamicPropertyPrefix( 8982 arg);
6314 Send node, 8983 }
6315 Node receiver, 8984
6316 IncDecOperator operator, 8985 @override
6317 Selector getterSelector, 8986 R visitUnresolvedSuperGetterCompound(
6318 Selector setterSelector, 8987 Send node, Element element,
6319 A arg) { 8988 MethodElement setter,
6320 return handleDynamicPostfixPrefix(
6321 node, receiver, operator,
6322 getterSelector, setterSelector, arg, isPrefix: true);
6323 }
6324
6325 @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(
6337 Send node,
6338 AssignmentOperator operator, 8989 AssignmentOperator operator,
6339 Node rhs, 8990 Node rhs,
6340 Selector getterSelector, 8991 A arg) {
6341 Selector setterSelector, 8992 return handleSuperCompound(
6342 A arg) { 8993 node,
6343 return handleDynamicCompound( 8994 element,
6344 node, null, operator, rhs, getterSelector, setterSelector, arg); 8995 CompoundGetter.UNRESOLVED,
6345 } 8996 setter,
6346 8997 CompoundSetter.SETTER,
6347 @override 8998 new AssignmentCompound(operator, rhs),
6348 R visitThisPropertyGet( 8999 arg);
6349 Send node, 9000 }
6350 Selector selector, 9001
6351 A arg) { 9002 @override
6352 return handleDynamicGet(node, null, selector, arg); 9003 R visitUnresolvedSuperGetterPostfix(
6353 } 9004 Send node,
6354 9005 Element element,
6355 @override 9006 MethodElement setter,
6356 R visitThisPropertyInvoke( 9007 IncDecOperator operator,
6357 Send node, 9008 A arg) {
6358 NodeList arguments, 9009 return handleSuperCompound(
6359 Selector selector, 9010 node,
6360 A arg) { 9011 element,
6361 return handleDynamicInvoke(node, null, arguments, selector, arg); 9012 CompoundGetter.UNRESOLVED,
6362 } 9013 setter,
6363 9014 CompoundSetter.SETTER,
6364 @override 9015 new IncDecCompound(CompoundKind.POSTFIX, operator),
6365 R visitThisPropertyPostfix( 9016 arg);
6366 Send node, 9017 }
6367 IncDecOperator operator, 9018
6368 Selector getterSelector, 9019 @override
6369 Selector setterSelector, 9020 R visitUnresolvedSuperGetterPrefix(
6370 A arg) { 9021 Send node,
6371 return handleDynamicPostfixPrefix( 9022 Element element,
6372 node, null, operator, 9023 MethodElement setter,
6373 getterSelector, setterSelector, arg, isPrefix: false); 9024 IncDecOperator operator,
6374 } 9025 A arg) {
6375 9026 return handleSuperCompound(
6376 @override 9027 node,
6377 R visitThisPropertyPrefix( 9028 element,
6378 Send node, 9029 CompoundGetter.UNRESOLVED,
6379 IncDecOperator operator, 9030 setter,
6380 Selector getterSelector, 9031 CompoundSetter.SETTER,
6381 Selector setterSelector, 9032 new IncDecCompound(CompoundKind.PREFIX, operator),
6382 A arg) { 9033 arg);
6383 return handleDynamicPostfixPrefix( 9034 }
6384 node, null, operator, 9035
6385 getterSelector, setterSelector, arg, isPrefix: true); 9036 @override
6386 } 9037 R visitUnresolvedSuperSetterCompound(
6387 9038 Send node,
6388 @override 9039 MethodElement getter,
6389 R visitThisPropertySet( 9040 Element element,
6390 SendSet node, 9041 AssignmentOperator operator,
6391 Selector selector,
6392 Node rhs, 9042 Node rhs,
6393 A arg) { 9043 A arg) {
6394 return handleDynamicSet(node, null, selector, rhs, arg); 9044 return handleSuperCompound(
6395 } 9045 node,
6396 9046 getter,
6397 @override 9047 CompoundGetter.GETTER,
6398 R visitIndexPostfix( 9048 element,
6399 Send node, 9049 CompoundSetter.INVALID,
6400 Node receiver, 9050 new AssignmentCompound(operator, rhs),
6401 Node index, 9051 arg);
6402 IncDecOperator operator, 9052 }
6403 A arg) { 9053
6404 return handleDynamicIndexPostfixPrefix( 9054 @override
6405 node, receiver, index, operator, arg, isPrefix: false); 9055 R visitUnresolvedSuperSetterPostfix(
6406 } 9056 Send node,
6407 9057 MethodElement getter,
6408 @override 9058 Element element,
6409 R visitIndexPrefix( 9059 IncDecOperator operator,
6410 Send node, 9060 A arg) {
6411 Node receiver, 9061 return handleSuperCompound(
6412 Node index, 9062 node,
6413 IncDecOperator operator, 9063 getter,
6414 A arg) { 9064 CompoundGetter.GETTER,
6415 return handleDynamicIndexPostfixPrefix( 9065 element,
6416 node, receiver, index, operator, arg, isPrefix: true); 9066 CompoundSetter.INVALID,
9067 new IncDecCompound(CompoundKind.POSTFIX, operator),
9068 arg);
9069 }
9070
9071 @override
9072 R visitUnresolvedSuperSetterPrefix(
9073 Send node,
9074 MethodElement getter,
9075 Element element,
9076 IncDecOperator operator,
9077 A arg) {
9078 return handleSuperCompound(
9079 node,
9080 getter,
9081 CompoundGetter.GETTER,
9082 element,
9083 CompoundSetter.INVALID,
9084 new IncDecCompound(CompoundKind.PREFIX, operator),
9085 arg);
6417 } 9086 }
6418 } 9087 }
6419 9088
6420 /// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by 9089 /// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by
6421 /// delegating calls to `handleSuperXPostfixPrefix` methods. 9090 /// delegating calls to `handleSuperXPostfixPrefix` methods.
6422 /// 9091 ///
6423 /// This mixin is useful for the cases where super prefix/postfix expression are 9092 /// This mixin is useful for the cases where super prefix/postfix expression are
6424 /// handled uniformly. 9093 /// handled uniformly.
6425 abstract class BaseImplementationOfSuperIncDecsMixin<R, A> 9094 abstract class BaseImplementationOfSuperIncDecsMixin<R, A>
6426 implements SemanticSendVisitor<R, A> { 9095 implements SemanticSendVisitor<R, A> {
(...skipping 257 matching lines...) Expand 10 before | Expand all | Expand 10 after
6684 R visitUnresolvedSuperSetterIndexPrefix( 9353 R visitUnresolvedSuperSetterIndexPrefix(
6685 Send node, 9354 Send node,
6686 MethodElement indexFunction, 9355 MethodElement indexFunction,
6687 Element element, 9356 Element element,
6688 Node index, 9357 Node index,
6689 IncDecOperator operator, 9358 IncDecOperator operator,
6690 A arg) { 9359 A arg) {
6691 return handleUnresolvedSuperSetterIndexPostfixPrefix( 9360 return handleUnresolvedSuperSetterIndexPostfixPrefix(
6692 node, indexFunction, element, index, operator, arg, isPrefix: true); 9361 node, indexFunction, element, index, operator, arg, isPrefix: true);
6693 } 9362 }
9363
9364 @override
9365 R visitSuperFinalFieldPostfix(
9366 Send node,
9367 FieldElement field,
9368 IncDecOperator operator,
9369 A arg) {
9370 // TODO: implement visitSuperFinalFieldPostfix
9371 }
9372
9373 @override
9374 R visitSuperMethodPostfix(
9375 Send node,
9376 FunctionElement method,
9377 IncDecOperator operator,
9378 A arg) {
9379 // TODO: implement visitSuperMethodPostfix
9380 }
9381
9382 @override
9383 R visitUnresolvedSuperPostfix(
9384 Send node,
9385 Element element,
9386 IncDecOperator operator,
9387 A arg) {
9388 // TODO: implement visitUnresolvedSuperPostfix
9389 }
9390
9391 @override
9392 R visitUnresolvedSuperGetterPostfix(
9393 Send node,
9394 Element element,
9395 MethodElement setter,
9396 IncDecOperator operator,
9397 A arg) {
9398 // TODO: implement visitUnresolvedSuperGetterPostfix
9399 }
9400
9401 @override
9402 R visitUnresolvedSuperGetterPrefix(
9403 Send node,
9404 Element element,
9405 MethodElement setter,
9406 IncDecOperator operator,
9407 A arg) {
9408 // TODO: implement visitUnresolvedSuperGetterPrefix
9409 }
9410
9411 @override
9412 R visitUnresolvedSuperSetterPostfix(
9413 Send node,
9414 MethodElement getter,
9415 Element element,
9416 IncDecOperator operator,
9417 A arg) {
9418 // TODO: implement visitUnresolvedSuperSetterPostfix
9419 }
9420
9421 @override
9422 R visitUnresolvedSuperSetterPrefix(
9423 Send node,
9424 MethodElement getter,
9425 Element element,
9426 IncDecOperator operator,
9427 A arg) {
9428 // TODO: implement visitUnresolvedSuperSetterPrefix
9429 }
6694 } 9430 }
6695 9431
6696 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by 9432 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by
6697 /// delegating calls to the `handleConstructorInvoke` method. 9433 /// delegating calls to the `handleConstructorInvoke` method.
6698 /// 9434 ///
6699 /// This mixin is useful for the cases where all constructor invocations are 9435 /// This mixin is useful for the cases where all constructor invocations are
6700 /// handled uniformly. 9436 /// handled uniformly.
6701 abstract class BaseImplementationOfNewMixin<R, A> 9437 abstract class BaseImplementationOfNewMixin<R, A>
6702 implements SemanticSendVisitor<R, A> { 9438 implements SemanticSendVisitor<R, A> {
6703 9439
6704 R handleConstructorInvoke( 9440 R handleConstructorInvoke(
6705 NewExpression node, 9441 NewExpression node,
6706 ConstructorElement constructor, 9442 ConstructorElement constructor,
6707 DartType type, 9443 DartType type,
6708 NodeList arguments, 9444 NodeList arguments,
6709 CallStructure callStructure, 9445 CallStructure callStructure,
6710 A arg); 9446 A arg);
6711 9447
6712 R visitGenerativeConstructorInvoke( 9448 R visitGenerativeConstructorInvoke(
6713 NewExpression node, 9449 NewExpression node,
6714 ConstructorElement constructor, 9450 ConstructorElement constructor,
6715 InterfaceType type, 9451 InterfaceType type,
6716 NodeList arguments, 9452 NodeList arguments,
6717 CallStructure callStructure, 9453 CallStructure callStructure,
6718 A arg) { 9454 A arg) {
6719 return handleConstructorInvoke( 9455 return handleConstructorInvoke(
6720 node, constructor, type, arguments, callStructure, arg); 9456 node, constructor, type, arguments, callStructure, arg);
6721 } 9457 }
6722 9458
9459 @override
6723 R visitRedirectingGenerativeConstructorInvoke( 9460 R visitRedirectingGenerativeConstructorInvoke(
6724 NewExpression node, 9461 NewExpression node,
6725 ConstructorElement constructor, 9462 ConstructorElement constructor,
6726 InterfaceType type, 9463 InterfaceType type,
6727 NodeList arguments, 9464 NodeList arguments,
6728 CallStructure callStructure, 9465 CallStructure callStructure,
6729 A arg) { 9466 A arg) {
6730 return handleConstructorInvoke( 9467 return handleConstructorInvoke(
6731 node, constructor, type, arguments, callStructure, arg); 9468 node, constructor, type, arguments, callStructure, arg);
6732 } 9469 }
6733 9470
9471 @override
6734 R visitFactoryConstructorInvoke( 9472 R visitFactoryConstructorInvoke(
6735 NewExpression node, 9473 NewExpression node,
6736 ConstructorElement constructor, 9474 ConstructorElement constructor,
6737 InterfaceType type, 9475 InterfaceType type,
6738 NodeList arguments, 9476 NodeList arguments,
6739 CallStructure callStructure, 9477 CallStructure callStructure,
6740 A arg) { 9478 A arg) {
6741 return handleConstructorInvoke( 9479 return handleConstructorInvoke(
6742 node, constructor, type, arguments, callStructure, arg); 9480 node, constructor, type, arguments, callStructure, arg);
6743 } 9481 }
6744 9482
9483 @override
6745 R visitRedirectingFactoryConstructorInvoke( 9484 R visitRedirectingFactoryConstructorInvoke(
6746 NewExpression node, 9485 NewExpression node,
6747 ConstructorElement constructor, 9486 ConstructorElement constructor,
6748 InterfaceType type, 9487 InterfaceType type,
6749 ConstructorElement effectiveTarget, 9488 ConstructorElement effectiveTarget,
6750 InterfaceType effectiveTargetType, 9489 InterfaceType effectiveTargetType,
6751 NodeList arguments, 9490 NodeList arguments,
6752 CallStructure callStructure, 9491 CallStructure callStructure,
6753 A arg) { 9492 A arg) {
6754 return handleConstructorInvoke( 9493 return handleConstructorInvoke(
6755 node, constructor, type, arguments, callStructure, arg); 9494 node, constructor, type, arguments, callStructure, arg);
6756 } 9495 }
6757 9496
9497 @override
6758 R visitUnresolvedConstructorInvoke( 9498 R visitUnresolvedConstructorInvoke(
6759 NewExpression node, 9499 NewExpression node,
6760 Element constructor, 9500 Element constructor,
6761 DartType type, 9501 DartType type,
6762 NodeList arguments, 9502 NodeList arguments,
6763 Selector selector, 9503 Selector selector,
6764 A arg) { 9504 A arg) {
6765 return handleConstructorInvoke( 9505 return handleConstructorInvoke(
6766 node, constructor, type, arguments, selector.callStructure, arg); 9506 node, constructor, type, arguments, selector.callStructure, arg);
6767 } 9507 }
6768 9508
9509 @override
6769 R visitUnresolvedClassConstructorInvoke( 9510 R visitUnresolvedClassConstructorInvoke(
6770 NewExpression node, 9511 NewExpression node,
6771 Element element, 9512 Element element,
6772 DartType type, 9513 DartType type,
6773 NodeList arguments, 9514 NodeList arguments,
6774 Selector selector, 9515 Selector selector,
6775 A arg) { 9516 A arg) {
6776 return handleConstructorInvoke( 9517 return handleConstructorInvoke(
6777 node, element, type, arguments, selector.callStructure, arg); 9518 node, element, type, arguments, selector.callStructure, arg);
6778 } 9519 }
6779 9520
9521 @override
6780 R visitAbstractClassConstructorInvoke( 9522 R visitAbstractClassConstructorInvoke(
6781 NewExpression node, 9523 NewExpression node,
6782 ConstructorElement constructor, 9524 ConstructorElement constructor,
6783 InterfaceType type, 9525 InterfaceType type,
6784 NodeList arguments, 9526 NodeList arguments,
6785 CallStructure callStructure, 9527 CallStructure callStructure,
6786 A arg) { 9528 A arg) {
6787 return handleConstructorInvoke( 9529 return handleConstructorInvoke(
6788 node, constructor, type, arguments, callStructure, arg); 9530 node, constructor, type, arguments, callStructure, arg);
6789 } 9531 }
9532
9533 @override
6790 R visitUnresolvedRedirectingFactoryConstructorInvoke( 9534 R visitUnresolvedRedirectingFactoryConstructorInvoke(
6791 NewExpression node, 9535 NewExpression node,
6792 ConstructorElement constructor, 9536 ConstructorElement constructor,
6793 InterfaceType type, 9537 InterfaceType type,
6794 NodeList arguments, 9538 NodeList arguments,
6795 CallStructure callStructure, 9539 CallStructure callStructure,
6796 A arg) { 9540 A arg) {
6797 return handleConstructorInvoke( 9541 return handleConstructorInvoke(
6798 node, constructor, type, arguments, callStructure, arg); 9542 node, constructor, type, arguments, callStructure, arg);
6799 } 9543 }
6800 } 9544 }
OLDNEW
« pkg/compiler/lib/src/resolution/semantic_visitor.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