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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 1033213002: Fix type annotation for deferred constants. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Update cf. comment. Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « pkg/compiler/lib/src/resolution/semantic_visitor.dart ('k') | pkg/compiler/lib/src/resolution/send_resolver.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file 1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
2 // for details. All rights reserved. Use of this source code is governed by a 2 // for details. All rights reserved. Use of this source code is governed by a
3 // BSD-style license that can be found in the LICENSE file. 3 // BSD-style license that can be found in the LICENSE file.
4 4
5 part of dart2js.semantics_visitor; 5 part of dart2js.semantics_visitor;
6 6
7 /// Mixin that implements all `errorX` methods of [SemanticSendVisitor] by 7 /// Mixin that implements all `errorX` methods of [SemanticSendVisitor] by
8 /// delegating to a bulk handler. 8 /// delegating to a bulk handler.
9 /// 9 ///
10 /// Use this mixin to provide a trivial implementation for all `errorX` methods. 10 /// Use this mixin to provide a trivial implementation for all `errorX` methods.
11 abstract class ErrorBulkMixin<R, A> implements SemanticSendVisitor<R, A> { 11 abstract class ErrorBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
12 R bulkHandleNode(Node node, String message, A arg); 12 R bulkHandleNode(Node node, String message, A arg);
13 13
14 R bulkHandleError(Send node, A arg) { 14 R bulkHandleError(Send node, A arg) {
15 return bulkHandleNode(node, "Error expression `$node` unhandled.", arg); 15 return bulkHandleNode(node, "Error expression `$node` unhandled.", arg);
16 } 16 }
17 17
18 @override 18 @override
19 R errorInvalidAssert( 19 R errorInvalidAssert(
20 Send node, 20 Send node,
21 NodeList arguments, 21 NodeList arguments,
22 A arg) { 22 A arg) {
23 return bulkHandleError(node, arg); 23 return bulkHandleError(node, arg);
24 } 24 }
25 25
26 @override 26 @override
27 R errorClassTypeLiteralCompound( 27 R errorClassTypeLiteralCompound(
28 Send node, 28 Send node,
29 TypeConstantExpression constant, 29 ConstantExpression constant,
30 AssignmentOperator operator, 30 AssignmentOperator operator,
31 Node rhs, 31 Node rhs,
32 A arg) { 32 A arg) {
33 return bulkHandleError(node, arg); 33 return bulkHandleError(node, arg);
34 } 34 }
35 35
36 @override 36 @override
37 R errorClassTypeLiteralPostfix( 37 R errorClassTypeLiteralPostfix(
38 Send node, 38 Send node,
39 TypeConstantExpression constant, 39 ConstantExpression constant,
40 IncDecOperator operator, 40 IncDecOperator operator,
41 A arg) { 41 A arg) {
42 return bulkHandleError(node, arg); 42 return bulkHandleError(node, arg);
43 } 43 }
44 44
45 @override 45 @override
46 R errorClassTypeLiteralPrefix( 46 R errorClassTypeLiteralPrefix(
47 Send node, 47 Send node,
48 TypeConstantExpression constant, 48 ConstantExpression constant,
49 IncDecOperator operator, 49 IncDecOperator operator,
50 A arg) { 50 A arg) {
51 return bulkHandleError(node, arg); 51 return bulkHandleError(node, arg);
52 } 52 }
53 53
54 @override 54 @override
55 R errorClassTypeLiteralSet( 55 R errorClassTypeLiteralSet(
56 SendSet node, 56 SendSet node,
57 TypeConstantExpression constant, 57 ConstantExpression constant,
58 Node rhs, 58 Node rhs,
59 A arg) { 59 A arg) {
60 return bulkHandleError(node, arg); 60 return bulkHandleError(node, arg);
61 } 61 }
62 62
63 @override 63 @override
64 R errorDynamicTypeLiteralCompound( 64 R errorDynamicTypeLiteralCompound(
65 Send node, 65 Send node,
66 TypeConstantExpression constant, 66 ConstantExpression constant,
67 AssignmentOperator operator, 67 AssignmentOperator operator,
68 Node rhs, 68 Node rhs,
69 A arg) { 69 A arg) {
70 return bulkHandleError(node, arg); 70 return bulkHandleError(node, arg);
71 } 71 }
72 72
73 @override 73 @override
74 R errorDynamicTypeLiteralPostfix( 74 R errorDynamicTypeLiteralPostfix(
75 Send node, 75 Send node,
76 TypeConstantExpression constant, 76 ConstantExpression constant,
77 IncDecOperator operator, 77 IncDecOperator operator,
78 A arg) { 78 A arg) {
79 return bulkHandleError(node, arg); 79 return bulkHandleError(node, arg);
80 } 80 }
81 81
82 @override 82 @override
83 R errorDynamicTypeLiteralPrefix( 83 R errorDynamicTypeLiteralPrefix(
84 Send node, 84 Send node,
85 TypeConstantExpression constant, 85 ConstantExpression constant,
86 IncDecOperator operator, 86 IncDecOperator operator,
87 A arg) { 87 A arg) {
88 return bulkHandleError(node, arg); 88 return bulkHandleError(node, arg);
89 } 89 }
90 90
91 @override 91 @override
92 R errorDynamicTypeLiteralSet( 92 R errorDynamicTypeLiteralSet(
93 SendSet node, 93 SendSet node,
94 TypeConstantExpression constant, 94 ConstantExpression constant,
95 Node rhs, 95 Node rhs,
96 A arg) { 96 A arg) {
97 return bulkHandleError(node, arg); 97 return bulkHandleError(node, arg);
98 } 98 }
99 99
100 @override 100 @override
101 R errorFinalLocalVariableCompound( 101 R errorFinalLocalVariableCompound(
102 Send node, 102 Send node,
103 LocalVariableElement 103 LocalVariableElement
104 variable, 104 variable,
(...skipping 266 matching lines...) Expand 10 before | Expand all | Expand 10 after
371 SendSet node, 371 SendSet node,
372 TypeVariableElement element, 372 TypeVariableElement element,
373 Node rhs, 373 Node rhs,
374 A arg) { 374 A arg) {
375 return bulkHandleError(node, arg); 375 return bulkHandleError(node, arg);
376 } 376 }
377 377
378 @override 378 @override
379 R errorTypedefTypeLiteralCompound( 379 R errorTypedefTypeLiteralCompound(
380 Send node, 380 Send node,
381 TypeConstantExpression constant, 381 ConstantExpression constant,
382 AssignmentOperator operator, 382 AssignmentOperator operator,
383 Node rhs, 383 Node rhs,
384 A arg) { 384 A arg) {
385 return bulkHandleError(node, arg); 385 return bulkHandleError(node, arg);
386 } 386 }
387 387
388 @override 388 @override
389 R errorTypedefTypeLiteralPostfix( 389 R errorTypedefTypeLiteralPostfix(
390 Send node, 390 Send node,
391 TypeConstantExpression constant, 391 ConstantExpression constant,
392 IncDecOperator operator, 392 IncDecOperator operator,
393 A arg) { 393 A arg) {
394 return bulkHandleError(node, arg); 394 return bulkHandleError(node, arg);
395 } 395 }
396 396
397 @override 397 @override
398 R errorTypedefTypeLiteralPrefix( 398 R errorTypedefTypeLiteralPrefix(
399 Send node, 399 Send node,
400 TypeConstantExpression constant, 400 ConstantExpression constant,
401 IncDecOperator operator, 401 IncDecOperator operator,
402 A arg) { 402 A arg) {
403 return bulkHandleError(node, arg); 403 return bulkHandleError(node, arg);
404 } 404 }
405 405
406 @override 406 @override
407 R errorTypedefTypeLiteralSet( 407 R errorTypedefTypeLiteralSet(
408 SendSet node, 408 SendSet node,
409 TypeConstantExpression constant, 409 ConstantExpression constant,
410 Node rhs, 410 Node rhs,
411 A arg) { 411 A arg) {
412 return bulkHandleError(node, arg); 412 return bulkHandleError(node, arg);
413 } 413 }
414 414
415 @override 415 @override
416 R errorUnresolvedCompound( 416 R errorUnresolvedCompound(
417 Send node, 417 Send node,
418 Element element, 418 Element element,
419 AssignmentOperator operator, 419 AssignmentOperator operator,
(...skipping 698 matching lines...) Expand 10 before | Expand all | Expand 10 after
1118 abstract class InvokeBulkMixin<R, A> implements SemanticSendVisitor<R, A> { 1118 abstract class InvokeBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
1119 R bulkHandleNode(Node node, String message, A arg); 1119 R bulkHandleNode(Node node, String message, A arg);
1120 1120
1121 R bulkHandleInvoke(Send node, A arg) { 1121 R bulkHandleInvoke(Send node, A arg) {
1122 return bulkHandleNode(node, "Invocation `$node` unhandled.", arg); 1122 return bulkHandleNode(node, "Invocation `$node` unhandled.", arg);
1123 } 1123 }
1124 1124
1125 @override 1125 @override
1126 R visitClassTypeLiteralInvoke( 1126 R visitClassTypeLiteralInvoke(
1127 Send node, 1127 Send node,
1128 TypeConstantExpression constant, 1128 ConstantExpression constant,
1129 NodeList arguments, 1129 NodeList arguments,
1130 Selector selector, 1130 Selector selector,
1131 A arg) { 1131 A arg) {
1132 return bulkHandleInvoke(node, arg); 1132 return bulkHandleInvoke(node, arg);
1133 } 1133 }
1134 1134
1135 @override 1135 @override
1136 R visitDynamicPropertyInvoke( 1136 R visitDynamicPropertyInvoke(
1137 Send node, 1137 Send node,
1138 Node receiver, 1138 Node receiver,
1139 NodeList arguments, 1139 NodeList arguments,
1140 Selector selector, 1140 Selector selector,
1141 A arg) { 1141 A arg) {
1142 return bulkHandleInvoke(node, arg); 1142 return bulkHandleInvoke(node, arg);
1143 } 1143 }
1144 1144
1145 @override 1145 @override
1146 R visitDynamicTypeLiteralInvoke( 1146 R visitDynamicTypeLiteralInvoke(
1147 Send node, 1147 Send node,
1148 TypeConstantExpression constant, 1148 ConstantExpression constant,
1149 NodeList arguments, 1149 NodeList arguments,
1150 Selector selector, 1150 Selector selector,
1151 A arg) { 1151 A arg) {
1152 return bulkHandleInvoke(node, arg); 1152 return bulkHandleInvoke(node, arg);
1153 } 1153 }
1154 1154
1155 @override 1155 @override
1156 R visitExpressionInvoke( 1156 R visitExpressionInvoke(
1157 Send node, 1157 Send node,
1158 Node expression, 1158 Node expression,
(...skipping 147 matching lines...) Expand 10 before | Expand all | Expand 10 after
1306 TypeVariableElement element, 1306 TypeVariableElement element,
1307 NodeList arguments, 1307 NodeList arguments,
1308 Selector selector, 1308 Selector selector,
1309 A arg) { 1309 A arg) {
1310 return bulkHandleInvoke(node, arg); 1310 return bulkHandleInvoke(node, arg);
1311 } 1311 }
1312 1312
1313 @override 1313 @override
1314 R visitTypedefTypeLiteralInvoke( 1314 R visitTypedefTypeLiteralInvoke(
1315 Send node, 1315 Send node,
1316 TypeConstantExpression constant, 1316 ConstantExpression constant,
1317 NodeList arguments, 1317 NodeList arguments,
1318 Selector selector, 1318 Selector selector,
1319 A arg) { 1319 A arg) {
1320 return bulkHandleInvoke(node, arg); 1320 return bulkHandleInvoke(node, arg);
1321 } 1321 }
1322 1322
1323 @override 1323 @override
1324 R visitConstantInvoke( 1324 R visitConstantInvoke(
1325 Send node, 1325 Send node,
1326 ConstantExpression constant, 1326 ConstantExpression constant,
(...skipping 12 matching lines...) Expand all
1339 abstract class GetBulkMixin<R, A> implements SemanticSendVisitor<R, A> { 1339 abstract class GetBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
1340 R bulkHandleNode(Node node, String message, A arg); 1340 R bulkHandleNode(Node node, String message, A arg);
1341 1341
1342 R bulkHandleGet(Node node, A arg) { 1342 R bulkHandleGet(Node node, A arg) {
1343 return bulkHandleNode(node, "Read `$node` unhandled.", arg); 1343 return bulkHandleNode(node, "Read `$node` unhandled.", arg);
1344 } 1344 }
1345 1345
1346 @override 1346 @override
1347 R visitClassTypeLiteralGet( 1347 R visitClassTypeLiteralGet(
1348 Send node, 1348 Send node,
1349 TypeConstantExpression constant, 1349 ConstantExpression constant,
1350 A arg) { 1350 A arg) {
1351 return bulkHandleGet(node, arg); 1351 return bulkHandleGet(node, arg);
1352 } 1352 }
1353 1353
1354 @override 1354 @override
1355 R visitDynamicPropertyGet( 1355 R visitDynamicPropertyGet(
1356 Send node, 1356 Send node,
1357 Node receiver, 1357 Node receiver,
1358 Selector selector, 1358 Selector selector,
1359 A arg) { 1359 A arg) {
1360 return bulkHandleGet(node, arg); 1360 return bulkHandleGet(node, arg);
1361 } 1361 }
1362 1362
1363 @override 1363 @override
1364 R visitDynamicTypeLiteralGet( 1364 R visitDynamicTypeLiteralGet(
1365 Send node, 1365 Send node,
1366 TypeConstantExpression constant, 1366 ConstantExpression constant,
1367 A arg) { 1367 A arg) {
1368 return bulkHandleGet(node, arg); 1368 return bulkHandleGet(node, arg);
1369 } 1369 }
1370 1370
1371 @override 1371 @override
1372 R visitLocalFunctionGet( 1372 R visitLocalFunctionGet(
1373 Send node, 1373 Send node,
1374 LocalFunctionElement function, 1374 LocalFunctionElement function,
1375 A arg) { 1375 A arg) {
1376 return bulkHandleGet(node, arg); 1376 return bulkHandleGet(node, arg);
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after
1481 R visitTypeVariableTypeLiteralGet( 1481 R visitTypeVariableTypeLiteralGet(
1482 Send node, 1482 Send node,
1483 TypeVariableElement element, 1483 TypeVariableElement element,
1484 A arg) { 1484 A arg) {
1485 return bulkHandleGet(node, arg); 1485 return bulkHandleGet(node, arg);
1486 } 1486 }
1487 1487
1488 @override 1488 @override
1489 R visitTypedefTypeLiteralGet( 1489 R visitTypedefTypeLiteralGet(
1490 Send node, 1490 Send node,
1491 TypeConstantExpression constant, 1491 ConstantExpression constant,
1492 A arg) { 1492 A arg) {
1493 return bulkHandleGet(node, arg); 1493 return bulkHandleGet(node, arg);
1494 } 1494 }
1495 1495
1496 @override 1496 @override
1497 R visitConstantGet( 1497 R visitConstantGet(
1498 Send node, 1498 Send node,
1499 TypeConstantExpression constant, 1499 ConstantExpression constant,
1500 A arg) { 1500 A arg) {
1501 return bulkHandleGet(node, arg); 1501 return bulkHandleGet(node, arg);
1502 } 1502 }
1503 } 1503 }
1504 1504
1505 /// Mixin that implements all `visitXSet` methods of [SemanticSendVisitor] by 1505 /// Mixin that implements all `visitXSet` methods of [SemanticSendVisitor] by
1506 /// delegating to a bulk handler. 1506 /// delegating to a bulk handler.
1507 /// 1507 ///
1508 /// Use this mixin to provide a trivial implementation for all `visitXSet` 1508 /// Use this mixin to provide a trivial implementation for all `visitXSet`
1509 /// methods. 1509 /// methods.
(...skipping 693 matching lines...) Expand 10 before | Expand all | Expand 10 after
2203 Send node, 2203 Send node,
2204 NodeList arguments, 2204 NodeList arguments,
2205 A arg) { 2205 A arg) {
2206 apply(arguments, arg); 2206 apply(arguments, arg);
2207 return null; 2207 return null;
2208 } 2208 }
2209 2209
2210 @override 2210 @override
2211 R errorClassTypeLiteralSet( 2211 R errorClassTypeLiteralSet(
2212 SendSet node, 2212 SendSet node,
2213 TypeConstantExpression constant, 2213 ConstantExpression constant,
2214 Node rhs, 2214 Node rhs,
2215 A arg) { 2215 A arg) {
2216 apply(rhs, arg); 2216 apply(rhs, arg);
2217 return null; 2217 return null;
2218 } 2218 }
2219 2219
2220 @override 2220 @override
2221 R errorDynamicTypeLiteralSet( 2221 R errorDynamicTypeLiteralSet(
2222 SendSet node, 2222 SendSet node,
2223 TypeConstantExpression constant, 2223 ConstantExpression constant,
2224 Node rhs, 2224 Node rhs,
2225 A arg) { 2225 A arg) {
2226 apply(rhs, arg); 2226 apply(rhs, arg);
2227 return null; 2227 return null;
2228 } 2228 }
2229 2229
2230 @override 2230 @override
2231 R errorFinalLocalVariableCompound( 2231 R errorFinalLocalVariableCompound(
2232 Send node, 2232 Send node,
2233 LocalVariableElement variable, 2233 LocalVariableElement variable,
(...skipping 260 matching lines...) Expand 10 before | Expand all | Expand 10 after
2494 TypeVariableElement element, 2494 TypeVariableElement element,
2495 Node rhs, 2495 Node rhs,
2496 A arg) { 2496 A arg) {
2497 apply(rhs, arg); 2497 apply(rhs, arg);
2498 return null; 2498 return null;
2499 } 2499 }
2500 2500
2501 @override 2501 @override
2502 R errorTypedefTypeLiteralSet( 2502 R errorTypedefTypeLiteralSet(
2503 SendSet node, 2503 SendSet node,
2504 TypeConstantExpression constant, 2504 ConstantExpression constant,
2505 Node rhs, 2505 Node rhs,
2506 A arg) { 2506 A arg) {
2507 apply(rhs, arg); 2507 apply(rhs, arg);
2508 return null; 2508 return null;
2509 } 2509 }
2510 2510
2511 @override 2511 @override
2512 R errorUnresolvedSuperIndex( 2512 R errorUnresolvedSuperIndex(
2513 Send node, 2513 Send node,
2514 Element function, 2514 Element function,
(...skipping 30 matching lines...) Expand all
2545 Node right, 2545 Node right,
2546 A arg) { 2546 A arg) {
2547 apply(left, arg); 2547 apply(left, arg);
2548 apply(right, arg); 2548 apply(right, arg);
2549 return null; 2549 return null;
2550 } 2550 }
2551 2551
2552 @override 2552 @override
2553 R errorClassTypeLiteralCompound( 2553 R errorClassTypeLiteralCompound(
2554 Send node, 2554 Send node,
2555 TypeConstantExpression constant, 2555 ConstantExpression constant,
2556 AssignmentOperator operator, 2556 AssignmentOperator operator,
2557 Node rhs, 2557 Node rhs,
2558 A arg) { 2558 A arg) {
2559 apply(rhs, arg); 2559 apply(rhs, arg);
2560 return null; 2560 return null;
2561 } 2561 }
2562 2562
2563 @override 2563 @override
2564 R visitClassTypeLiteralGet( 2564 R visitClassTypeLiteralGet(
2565 Send node, 2565 Send node,
2566 TypeConstantExpression constant, 2566 ConstantExpression constant,
2567 A arg) { 2567 A arg) {
2568 return null; 2568 return null;
2569 } 2569 }
2570 2570
2571 @override 2571 @override
2572 R visitClassTypeLiteralInvoke( 2572 R visitClassTypeLiteralInvoke(
2573 Send node, 2573 Send node,
2574 TypeConstantExpression constant, 2574 ConstantExpression constant,
2575 NodeList arguments, 2575 NodeList arguments,
2576 Selector selector, 2576 Selector selector,
2577 A arg) { 2577 A arg) {
2578 apply(arguments, arg); 2578 apply(arguments, arg);
2579 return null; 2579 return null;
2580 } 2580 }
2581 2581
2582 @override 2582 @override
2583 R errorClassTypeLiteralPostfix( 2583 R errorClassTypeLiteralPostfix(
2584 Send node, 2584 Send node,
2585 TypeConstantExpression constant, 2585 ConstantExpression constant,
2586 IncDecOperator operator, 2586 IncDecOperator operator,
2587 A arg) { 2587 A arg) {
2588 return null; 2588 return null;
2589 } 2589 }
2590 2590
2591 @override 2591 @override
2592 R errorClassTypeLiteralPrefix( 2592 R errorClassTypeLiteralPrefix(
2593 Send node, 2593 Send node,
2594 TypeConstantExpression constant, 2594 ConstantExpression constant,
2595 IncDecOperator operator, 2595 IncDecOperator operator,
2596 A arg) { 2596 A arg) {
2597 return null; 2597 return null;
2598 } 2598 }
2599 2599
2600 @override 2600 @override
2601 R visitCompoundIndexSet( 2601 R visitCompoundIndexSet(
2602 SendSet node, 2602 SendSet node,
2603 Node receiver, 2603 Node receiver,
2604 Node index, 2604 Node index,
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after
2697 Selector selector, 2697 Selector selector,
2698 Node rhs, 2698 Node rhs,
2699 A arg) { 2699 A arg) {
2700 apply(rhs, arg); 2700 apply(rhs, arg);
2701 return null; 2701 return null;
2702 } 2702 }
2703 2703
2704 @override 2704 @override
2705 R errorDynamicTypeLiteralCompound( 2705 R errorDynamicTypeLiteralCompound(
2706 Send node, 2706 Send node,
2707 TypeConstantExpression constant, 2707 ConstantExpression constant,
2708 AssignmentOperator operator, 2708 AssignmentOperator operator,
2709 Node rhs, 2709 Node rhs,
2710 A arg) { 2710 A arg) {
2711 apply(rhs, arg); 2711 apply(rhs, arg);
2712 return null; 2712 return null;
2713 } 2713 }
2714 2714
2715 @override 2715 @override
2716 R visitDynamicTypeLiteralGet( 2716 R visitDynamicTypeLiteralGet(
2717 Send node, 2717 Send node,
2718 TypeConstantExpression constant, 2718 ConstantExpression constant,
2719 A arg) { 2719 A arg) {
2720 return null; 2720 return null;
2721 } 2721 }
2722 2722
2723 @override 2723 @override
2724 R visitDynamicTypeLiteralInvoke( 2724 R visitDynamicTypeLiteralInvoke(
2725 Send node, 2725 Send node,
2726 TypeConstantExpression constant, 2726 ConstantExpression constant,
2727 NodeList arguments, 2727 NodeList arguments,
2728 Selector selector, 2728 Selector selector,
2729 A arg) { 2729 A arg) {
2730 apply(arguments, arg); 2730 apply(arguments, arg);
2731 return null; 2731 return null;
2732 } 2732 }
2733 2733
2734 @override 2734 @override
2735 R errorDynamicTypeLiteralPostfix( 2735 R errorDynamicTypeLiteralPostfix(
2736 Send node, 2736 Send node,
2737 TypeConstantExpression constant, 2737 ConstantExpression constant,
2738 IncDecOperator operator, 2738 IncDecOperator operator,
2739 A arg) { 2739 A arg) {
2740 return null; 2740 return null;
2741 } 2741 }
2742 2742
2743 @override 2743 @override
2744 R errorDynamicTypeLiteralPrefix( 2744 R errorDynamicTypeLiteralPrefix(
2745 Send node, 2745 Send node,
2746 TypeConstantExpression constant, 2746 ConstantExpression constant,
2747 IncDecOperator operator, 2747 IncDecOperator operator,
2748 A arg) { 2748 A arg) {
2749 return null; 2749 return null;
2750 } 2750 }
2751 2751
2752 @override 2752 @override
2753 R visitEquals( 2753 R visitEquals(
2754 Send node, 2754 Send node,
2755 Node left, 2755 Node left,
2756 Node right, 2756 Node right,
(...skipping 1024 matching lines...) Expand 10 before | Expand all | Expand 10 after
3781 Send node, 3781 Send node,
3782 TypeVariableElement element, 3782 TypeVariableElement element,
3783 IncDecOperator operator, 3783 IncDecOperator operator,
3784 A arg) { 3784 A arg) {
3785 return null; 3785 return null;
3786 } 3786 }
3787 3787
3788 @override 3788 @override
3789 R errorTypedefTypeLiteralCompound( 3789 R errorTypedefTypeLiteralCompound(
3790 Send node, 3790 Send node,
3791 TypeConstantExpression constant, 3791 ConstantExpression constant,
3792 AssignmentOperator operator, 3792 AssignmentOperator operator,
3793 Node rhs, 3793 Node rhs,
3794 A arg) { 3794 A arg) {
3795 apply(rhs, arg); 3795 apply(rhs, arg);
3796 return null; 3796 return null;
3797 } 3797 }
3798 3798
3799 @override 3799 @override
3800 R visitTypedefTypeLiteralGet( 3800 R visitTypedefTypeLiteralGet(
3801 Send node, 3801 Send node,
3802 TypeConstantExpression constant, 3802 ConstantExpression constant,
3803 A arg) { 3803 A arg) {
3804 return null; 3804 return null;
3805 } 3805 }
3806 3806
3807 @override 3807 @override
3808 R visitTypedefTypeLiteralInvoke( 3808 R visitTypedefTypeLiteralInvoke(
3809 Send node, 3809 Send node,
3810 TypeConstantExpression constant, 3810 ConstantExpression constant,
3811 NodeList arguments, 3811 NodeList arguments,
3812 Selector selector, 3812 Selector selector,
3813 A arg) { 3813 A arg) {
3814 apply(arguments, arg); 3814 apply(arguments, arg);
3815 return null; 3815 return null;
3816 } 3816 }
3817 3817
3818 @override 3818 @override
3819 R errorTypedefTypeLiteralPostfix( 3819 R errorTypedefTypeLiteralPostfix(
3820 Send node, 3820 Send node,
3821 TypeConstantExpression constant, 3821 ConstantExpression constant,
3822 IncDecOperator operator, 3822 IncDecOperator operator,
3823 A arg) { 3823 A arg) {
3824 return null; 3824 return null;
3825 } 3825 }
3826 3826
3827 @override 3827 @override
3828 R errorTypedefTypeLiteralPrefix( 3828 R errorTypedefTypeLiteralPrefix(
3829 Send node, 3829 Send node,
3830 TypeConstantExpression constant, 3830 ConstantExpression constant,
3831 IncDecOperator operator, 3831 IncDecOperator operator,
3832 A arg) { 3832 A arg) {
3833 return null; 3833 return null;
3834 } 3834 }
3835 3835
3836 @override 3836 @override
3837 R visitUnary( 3837 R visitUnary(
3838 Send node, 3838 Send node,
3839 UnaryOperator operator, 3839 UnaryOperator operator,
3840 Node expression, 3840 Node expression,
(...skipping 880 matching lines...) Expand 10 before | Expand all | Expand 10 after
4721 R handleConstantInvoke( 4721 R handleConstantInvoke(
4722 Send node, 4722 Send node,
4723 ConstantExpression constant, 4723 ConstantExpression constant,
4724 NodeList arguments, 4724 NodeList arguments,
4725 Selector selector, 4725 Selector selector,
4726 A arg); 4726 A arg);
4727 4727
4728 @override 4728 @override
4729 R visitClassTypeLiteralGet( 4729 R visitClassTypeLiteralGet(
4730 Send node, 4730 Send node,
4731 TypeConstantExpression constant, 4731 ConstantExpression constant,
4732 A arg) { 4732 A arg) {
4733 return handleConstantGet(node, constant, arg); 4733 return handleConstantGet(node, constant, arg);
4734 } 4734 }
4735 4735
4736 @override 4736 @override
4737 R visitClassTypeLiteralInvoke( 4737 R visitClassTypeLiteralInvoke(
4738 Send node, 4738 Send node,
4739 TypeConstantExpression constant, 4739 ConstantExpression constant,
4740 NodeList arguments, 4740 NodeList arguments,
4741 Selector selector, 4741 Selector selector,
4742 A arg) { 4742 A arg) {
4743 return handleConstantInvoke(node, constant, arguments, selector, arg); 4743 return handleConstantInvoke(node, constant, arguments, selector, arg);
4744 } 4744 }
4745 4745
4746 @override 4746 @override
4747 R visitConstantGet( 4747 R visitConstantGet(
4748 Send node, 4748 Send node,
4749 ConstantExpression constant, 4749 ConstantExpression constant,
4750 A arg) { 4750 A arg) {
4751 return handleConstantGet(node, constant, arg); 4751 return handleConstantGet(node, constant, arg);
4752 } 4752 }
4753 4753
4754 @override 4754 @override
4755 R visitConstantInvoke( 4755 R visitConstantInvoke(
4756 Send node, 4756 Send node,
4757 ConstantExpression constant, 4757 ConstantExpression constant,
4758 NodeList arguments, 4758 NodeList arguments,
4759 Selector selector, 4759 Selector selector,
4760 A arg) { 4760 A arg) {
4761 return handleConstantInvoke(node, constant, arguments, selector, arg); 4761 return handleConstantInvoke(node, constant, arguments, selector, arg);
4762 } 4762 }
4763 4763
4764 @override 4764 @override
4765 R visitDynamicTypeLiteralGet( 4765 R visitDynamicTypeLiteralGet(
4766 Send node, 4766 Send node,
4767 TypeConstantExpression constant, 4767 ConstantExpression constant,
4768 A arg) { 4768 A arg) {
4769 return handleConstantGet(node, constant, arg); 4769 return handleConstantGet(node, constant, arg);
4770 } 4770 }
4771 4771
4772 @override 4772 @override
4773 R visitDynamicTypeLiteralInvoke( 4773 R visitDynamicTypeLiteralInvoke(
4774 Send node, 4774 Send node,
4775 TypeConstantExpression constant, 4775 ConstantExpression constant,
4776 NodeList arguments, 4776 NodeList arguments,
4777 Selector selector, 4777 Selector selector,
4778 A arg) { 4778 A arg) {
4779 return handleConstantInvoke(node, constant, arguments, selector, arg); 4779 return handleConstantInvoke(node, constant, arguments, selector, arg);
4780 } 4780 }
4781 4781
4782 @override 4782 @override
4783 R visitTypedefTypeLiteralGet( 4783 R visitTypedefTypeLiteralGet(
4784 Send node, 4784 Send node,
4785 TypeConstantExpression constant, 4785 ConstantExpression constant,
4786 A arg) { 4786 A arg) {
4787 return handleConstantGet(node, constant, arg); 4787 return handleConstantGet(node, constant, arg);
4788 } 4788 }
4789 4789
4790 @override 4790 @override
4791 R visitTypedefTypeLiteralInvoke( 4791 R visitTypedefTypeLiteralInvoke(
4792 Send node, 4792 Send node,
4793 TypeConstantExpression constant, 4793 ConstantExpression constant,
4794 NodeList arguments, 4794 NodeList arguments,
4795 Selector selector, 4795 Selector selector,
4796 A arg) { 4796 A arg) {
4797 return handleConstantInvoke(node, constant, arguments, selector, arg); 4797 return handleConstantInvoke(node, constant, arguments, selector, arg);
4798 } 4798 }
4799 } 4799 }
4800 4800
4801 /// Mixin that groups all `visitDynamicPropertyX` and `visitThisPropertyY` 4801 /// Mixin that groups all `visitDynamicPropertyX` and `visitThisPropertyY`
4802 /// methods for by delegating calls to `handleDynamicX` methods, providing 4802 /// methods for by delegating calls to `handleDynamicX` methods, providing
4803 /// `null` as the receiver for the this properties. 4803 /// `null` as the receiver for the this properties.
(...skipping 406 matching lines...) Expand 10 before | Expand all | Expand 10 after
5210 FunctionElement indexFunction, 5210 FunctionElement indexFunction,
5211 FunctionElement indexSetFunction, 5211 FunctionElement indexSetFunction,
5212 Node index, 5212 Node index,
5213 IncDecOperator operator, 5213 IncDecOperator operator,
5214 A arg) { 5214 A arg) {
5215 return handleSuperIndexPostfixPrefix( 5215 return handleSuperIndexPostfixPrefix(
5216 node, indexFunction, indexSetFunction, 5216 node, indexFunction, indexSetFunction,
5217 index, operator, arg, isPrefix: true); 5217 index, operator, arg, isPrefix: true);
5218 } 5218 }
5219 } 5219 }
OLDNEW
« no previous file with comments | « pkg/compiler/lib/src/resolution/semantic_visitor.dart ('k') | pkg/compiler/lib/src/resolution/send_resolver.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698