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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 1313323002: Add visitor methods specific to ??= to SemanticSendVisitor. (Closed) Base URL: https://github.com/dart-lang/sdk.git@master
Patch Set: Updated cf. comments. Created 5 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « pkg/compiler/lib/src/resolution/semantic_visitor.dart ('k') | pkg/compiler/lib/src/resolution/send_structure.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 187 matching lines...) Expand 10 before | Expand all | Expand 10 after
198 198
199 @override 199 @override
200 R errorInvalidIndexPostfix( 200 R errorInvalidIndexPostfix(
201 Send node, 201 Send node,
202 ErroneousElement error, 202 ErroneousElement error,
203 Node index, 203 Node index,
204 IncDecOperator operator, 204 IncDecOperator operator,
205 A arg) { 205 A arg) {
206 return bulkHandleError(node, error, arg); 206 return bulkHandleError(node, error, arg);
207 } 207 }
208
209 @override
210 R errorInvalidSetIfNull(
211 Send node,
212 ErroneousElement error,
213 Node rhs,
214 A arg) {
215 return bulkHandleError(node, error, arg);
216 }
208 } 217 }
209 218
210 /// Mixin that implements all `visitXPrefix` methods of [SemanticSendVisitor] by 219 /// Mixin that implements all `visitXPrefix` methods of [SemanticSendVisitor] by
211 /// delegating to a bulk handler. 220 /// delegating to a bulk handler.
212 /// 221 ///
213 /// Use this mixin to provide a trivial implementation for all `visitXPrefix` 222 /// Use this mixin to provide a trivial implementation for all `visitXPrefix`
214 /// methods. 223 /// methods.
215 abstract class PrefixBulkMixin<R, A> 224 abstract class PrefixBulkMixin<R, A>
216 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 225 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
217 226
(...skipping 1246 matching lines...) Expand 10 before | Expand all | Expand 10 after
1464 R visitUnresolvedSuperSetterCompound( 1473 R visitUnresolvedSuperSetterCompound(
1465 Send node, MethodElement getter, 1474 Send node, MethodElement getter,
1466 Element element, 1475 Element element,
1467 AssignmentOperator operator, 1476 AssignmentOperator operator,
1468 Node rhs, 1477 Node rhs,
1469 A arg) { 1478 A arg) {
1470 return bulkHandleCompound(node, arg); 1479 return bulkHandleCompound(node, arg);
1471 } 1480 }
1472 } 1481 }
1473 1482
1483 /// Mixin that implements all `visitXSetIfNull` methods of [SemanticSendVisitor]
1484 /// by delegating to a bulk handler.
1485 ///
1486 /// Use this mixin to provide a trivial implementation for all `xSetIfNull`
1487 /// methods.
1488 abstract class SetIfNullBulkMixin<R, A>
1489 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
1490
1491 R bulkHandleSetIfNull(Send node, A arg) {
1492 return bulkHandleNode(node, "If null assignment `#` unhandled.", arg);
1493 }
1494
1495 @override
1496 R visitClassTypeLiteralSetIfNull(
1497 Send node,
1498 ConstantExpression constant,
1499 Node rhs,
1500 A arg) {
1501 return bulkHandleSetIfNull(node, arg);
1502 }
1503
1504 @override
1505 R visitDynamicPropertySetIfNull(
1506 Send node,
1507 Node receiver,
1508 Name name,
1509 Node rhs,
1510 A arg) {
1511 return bulkHandleSetIfNull(node, arg);
1512 }
1513
1514 @override
1515 R visitDynamicTypeLiteralSetIfNull(
1516 Send node,
1517 ConstantExpression constant,
1518 Node rhs,
1519 A arg) {
1520 return bulkHandleSetIfNull(node, arg);
1521 }
1522
1523 @override
1524 R visitFinalLocalVariableSetIfNull(
1525 Send node,
1526 LocalVariableElement variable,
1527 Node rhs,
1528 A arg) {
1529 return bulkHandleSetIfNull(node, arg);
1530 }
1531
1532 @override
1533 R visitFinalParameterSetIfNull(
1534 Send node,
1535 ParameterElement parameter,
1536 Node rhs,
1537 A arg) {
1538 return bulkHandleSetIfNull(node, arg);
1539 }
1540
1541 @override
1542 R visitFinalStaticFieldSetIfNull(
1543 Send node,
1544 FieldElement field,
1545 Node rhs,
1546 A arg) {
1547 return bulkHandleSetIfNull(node, arg);
1548 }
1549
1550 @override
1551 R visitFinalSuperFieldSetIfNull(
1552 Send node,
1553 FieldElement field,
1554 Node rhs,
1555 A arg) {
1556 return bulkHandleSetIfNull(node, arg);
1557 }
1558
1559 @override
1560 R visitFinalTopLevelFieldSetIfNull(
1561 Send node,
1562 FieldElement field,
1563 Node rhs,
1564 A arg) {
1565 return bulkHandleSetIfNull(node, arg);
1566 }
1567
1568 @override
1569 R visitIfNotNullDynamicPropertySetIfNull(
1570 Send node,
1571 Node receiver,
1572 Name name,
1573 Node rhs,
1574 A arg) {
1575 return bulkHandleSetIfNull(node, arg);
1576 }
1577
1578 @override
1579 R visitLocalFunctionSetIfNull(
1580 Send node,
1581 LocalFunctionElement function,
1582 Node rhs,
1583 A arg) {
1584 return bulkHandleSetIfNull(node, arg);
1585 }
1586
1587 @override
1588 R visitLocalVariableSetIfNull(
1589 Send node,
1590 LocalVariableElement variable,
1591 Node rhs,
1592 A arg) {
1593 return bulkHandleSetIfNull(node, arg);
1594 }
1595
1596 @override
1597 R visitParameterSetIfNull(
1598 Send node,
1599 ParameterElement parameter,
1600 Node rhs,
1601 A arg) {
1602 return bulkHandleSetIfNull(node, arg);
1603 }
1604
1605 @override
1606 R visitStaticFieldSetIfNull(
1607 Send node,
1608 FieldElement field,
1609 Node rhs,
1610 A arg) {
1611 return bulkHandleSetIfNull(node, arg);
1612 }
1613
1614 @override
1615 R visitStaticGetterSetterSetIfNull(
1616 Send node,
1617 FunctionElement getter,
1618 FunctionElement setter,
1619 Node rhs,
1620 A arg) {
1621 return bulkHandleSetIfNull(node, arg);
1622 }
1623
1624 @override
1625 R visitStaticMethodSetIfNull(
1626 Send node,
1627 FunctionElement method,
1628 Node rhs,
1629 A arg) {
1630 return bulkHandleSetIfNull(node, arg);
1631 }
1632
1633 @override
1634 R visitStaticMethodSetterSetIfNull(
1635 Send node,
1636 MethodElement method,
1637 MethodElement setter,
1638 Node rhs,
1639 A arg) {
1640 return bulkHandleSetIfNull(node, arg);
1641 }
1642
1643 @override
1644 R visitSuperFieldFieldSetIfNull(
1645 Send node,
1646 FieldElement readField,
1647 FieldElement writtenField,
1648 Node rhs,
1649 A arg) {
1650 return bulkHandleSetIfNull(node, arg);
1651 }
1652
1653 @override
1654 R visitSuperFieldSetIfNull(
1655 Send node,
1656 FieldElement field,
1657 Node rhs,
1658 A arg) {
1659 return bulkHandleSetIfNull(node, arg);
1660 }
1661
1662 @override
1663 R visitSuperFieldSetterSetIfNull(
1664 Send node,
1665 FieldElement field,
1666 FunctionElement setter,
1667 Node rhs,
1668 A arg) {
1669 return bulkHandleSetIfNull(node, arg);
1670 }
1671
1672 @override
1673 R visitSuperGetterFieldSetIfNull(
1674 Send node,
1675 FunctionElement getter,
1676 FieldElement field,
1677 Node rhs,
1678 A arg) {
1679 return bulkHandleSetIfNull(node, arg);
1680 }
1681
1682 @override
1683 R visitSuperGetterSetterSetIfNull(
1684 Send node,
1685 FunctionElement getter,
1686 FunctionElement setter,
1687 Node rhs,
1688 A arg) {
1689 return bulkHandleSetIfNull(node, arg);
1690 }
1691
1692 @override
1693 R visitSuperMethodSetIfNull(
1694 Send node,
1695 FunctionElement method,
1696 Node rhs,
1697 A arg) {
1698 return bulkHandleSetIfNull(node, arg);
1699 }
1700
1701 @override
1702 R visitSuperMethodSetterSetIfNull(
1703 Send node,
1704 FunctionElement method,
1705 FunctionElement setter,
1706 Node rhs,
1707 A arg) {
1708 return bulkHandleSetIfNull(node, arg);
1709 }
1710
1711 @override
1712 R visitThisPropertySetIfNull(
1713 Send node,
1714 Name name,
1715 Node rhs,
1716 A arg) {
1717 return bulkHandleSetIfNull(node, arg);
1718 }
1719
1720 @override
1721 R visitTopLevelFieldSetIfNull(
1722 Send node,
1723 FieldElement field,
1724 Node rhs,
1725 A arg) {
1726 return bulkHandleSetIfNull(node, arg);
1727 }
1728
1729 @override
1730 R visitTopLevelGetterSetterSetIfNull(
1731 Send node,
1732 FunctionElement getter,
1733 FunctionElement setter,
1734 Node rhs,
1735 A arg) {
1736 return bulkHandleSetIfNull(node, arg);
1737 }
1738
1739 @override
1740 R visitTopLevelMethodSetIfNull(
1741 Send node,
1742 FunctionElement method,
1743 Node rhs,
1744 A arg) {
1745 return bulkHandleSetIfNull(node, arg);
1746 }
1747
1748 @override
1749 R visitTopLevelMethodSetterSetIfNull(
1750 Send node,
1751 FunctionElement method,
1752 FunctionElement setter,
1753 Node rhs,
1754 A arg) {
1755 return bulkHandleSetIfNull(node, arg);
1756 }
1757
1758 @override
1759 R visitTypeVariableTypeLiteralSetIfNull(
1760 Send node,
1761 TypeVariableElement element,
1762 Node rhs,
1763 A arg) {
1764 return bulkHandleSetIfNull(node, arg);
1765 }
1766
1767 @override
1768 R visitTypedefTypeLiteralSetIfNull(
1769 Send node,
1770 ConstantExpression constant,
1771 Node rhs,
1772 A arg) {
1773 return bulkHandleSetIfNull(node, arg);
1774 }
1775
1776 @override
1777 R visitUnresolvedSetIfNull(
1778 Send node,
1779 Element element,
1780 Node rhs,
1781 A arg) {
1782 return bulkHandleSetIfNull(node, arg);
1783 }
1784
1785 @override
1786 R visitUnresolvedStaticGetterSetIfNull(
1787 Send node,
1788 Element element,
1789 MethodElement setter,
1790 Node rhs,
1791 A arg) {
1792 return bulkHandleSetIfNull(node, arg);
1793 }
1794
1795 @override
1796 R visitUnresolvedStaticSetterSetIfNull(
1797 Send node,
1798 MethodElement getter,
1799 Element element,
1800 Node rhs,
1801 A arg) {
1802 return bulkHandleSetIfNull(node, arg);
1803 }
1804
1805 @override
1806 R visitUnresolvedSuperGetterSetIfNull(
1807 Send node,
1808 Element element,
1809 MethodElement setter,
1810 Node rhs,
1811 A arg) {
1812 return bulkHandleSetIfNull(node, arg);
1813 }
1814
1815 @override
1816 R visitUnresolvedSuperSetIfNull(
1817 Send node,
1818 Element element,
1819 Node rhs,
1820 A arg) {
1821 return bulkHandleSetIfNull(node, arg);
1822 }
1823
1824 @override
1825 R visitUnresolvedSuperSetterSetIfNull(
1826 Send node,
1827 MethodElement getter,
1828 Element element,
1829 Node rhs,
1830 A arg) {
1831 return bulkHandleSetIfNull(node, arg);
1832 }
1833
1834 @override
1835 R visitUnresolvedTopLevelGetterSetIfNull(
1836 Send node,
1837 Element element,
1838 MethodElement setter,
1839 Node rhs,
1840 A arg) {
1841 return bulkHandleSetIfNull(node, arg);
1842 }
1843
1844 @override
1845 R visitUnresolvedTopLevelSetterSetIfNull(
1846 Send node,
1847 MethodElement getter,
1848 Element element,
1849 Node rhs,
1850 A arg) {
1851 return bulkHandleSetIfNull(node, arg);
1852 }
1853 }
1854
1474 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by 1855 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by
1475 /// delegating to a bulk handler. 1856 /// delegating to a bulk handler.
1476 /// 1857 ///
1477 /// Use this mixin to provide a trivial implementation for all `visitXInvoke` 1858 /// Use this mixin to provide a trivial implementation for all `visitXInvoke`
1478 /// methods. 1859 /// methods.
1479 abstract class InvokeBulkMixin<R, A> 1860 abstract class InvokeBulkMixin<R, A>
1480 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> { 1861 implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
1481 1862
1482 R bulkHandleInvoke(Send node, A arg) { 1863 R bulkHandleInvoke(Send node, A arg) {
1483 return bulkHandleNode(node, "Invocation `#` unhandled.", arg); 1864 return bulkHandleNode(node, "Invocation `#` unhandled.", arg);
(...skipping 1658 matching lines...) Expand 10 before | Expand all | Expand 10 after
3142 /// This class is useful in itself, but shows how to use the `BulkX` mixins and 3523 /// This class is useful in itself, but shows how to use the `BulkX` mixins and
3143 /// tests that the union of the `BulkX` mixins implement all `visit` and `error` 3524 /// tests that the union of the `BulkX` mixins implement all `visit` and `error`
3144 /// methods of [SemanticSendVisitor]. 3525 /// methods of [SemanticSendVisitor].
3145 class BulkSendVisitor<R, A> extends SemanticSendVisitor<R, A> 3526 class BulkSendVisitor<R, A> extends SemanticSendVisitor<R, A>
3146 with GetBulkMixin<R, A>, 3527 with GetBulkMixin<R, A>,
3147 SetBulkMixin<R, A>, 3528 SetBulkMixin<R, A>,
3148 ErrorBulkMixin<R, A>, 3529 ErrorBulkMixin<R, A>,
3149 InvokeBulkMixin<R, A>, 3530 InvokeBulkMixin<R, A>,
3150 IndexSetBulkMixin<R, A>, 3531 IndexSetBulkMixin<R, A>,
3151 CompoundBulkMixin<R, A>, 3532 CompoundBulkMixin<R, A>,
3533 SetIfNullBulkMixin<R, A>,
3152 UnaryBulkMixin<R, A>, 3534 UnaryBulkMixin<R, A>,
3153 BaseBulkMixin<R, A>, 3535 BaseBulkMixin<R, A>,
3154 BinaryBulkMixin<R, A>, 3536 BinaryBulkMixin<R, A>,
3155 PrefixBulkMixin<R, A>, 3537 PrefixBulkMixin<R, A>,
3156 PostfixBulkMixin<R, A>, 3538 PostfixBulkMixin<R, A>,
3157 NewBulkMixin<R, A> { 3539 NewBulkMixin<R, A> {
3158 @override 3540 @override
3159 R apply(Node node, A arg) { 3541 R apply(Node node, A arg) {
3160 throw new UnimplementedError("BulkSendVisitor.apply unimplemented"); 3542 throw new UnimplementedError("BulkSendVisitor.apply unimplemented");
3161 } 3543 }
(...skipping 2689 matching lines...) Expand 10 before | Expand all | Expand 10 after
5851 FunctionElement indexFunction, 6233 FunctionElement indexFunction,
5852 FunctionElement indexSetFunction, 6234 FunctionElement indexSetFunction,
5853 Node index, 6235 Node index,
5854 IncDecOperator operator, 6236 IncDecOperator operator,
5855 A arg) { 6237 A arg) {
5856 apply(index, arg); 6238 apply(index, arg);
5857 return null; 6239 return null;
5858 } 6240 }
5859 6241
5860 @override 6242 @override
5861 R visitConstConstructorInvoke( 6243 R errorInvalidSetIfNull(
5862 NewExpression node, 6244 Send node,
5863 ConstructedConstantExpression constant, 6245 ErroneousElement error,
6246 Node rhs,
5864 A arg) { 6247 A arg) {
6248 apply(rhs, arg);
5865 return null; 6249 return null;
5866 } 6250 }
5867 6251
5868 @override 6252 @override
5869 R visitBoolFromEnvironmentConstructorInvoke( 6253 R visitClassTypeLiteralSetIfNull(
5870 NewExpression node, 6254 Send node,
5871 BoolFromEnvironmentConstantExpression constant, 6255 ConstantExpression constant,
6256 Node rhs,
5872 A arg) { 6257 A arg) {
6258 apply(rhs, arg);
5873 return null; 6259 return null;
5874 } 6260 }
5875 6261
5876 @override 6262 @override
5877 R visitIntFromEnvironmentConstructorInvoke( 6263 R visitDynamicPropertySetIfNull(
5878 NewExpression node, 6264 Send node,
5879 IntFromEnvironmentConstantExpression constant, 6265 Node receiver,
6266 Name name,
6267 Node rhs,
5880 A arg) { 6268 A arg) {
6269 apply(receiver, arg);
6270 apply(rhs, arg);
5881 return null; 6271 return null;
5882 } 6272 }
5883 6273
5884 @override 6274 @override
5885 R visitStringFromEnvironmentConstructorInvoke( 6275 R visitDynamicTypeLiteralSetIfNull(
5886 NewExpression node, 6276 Send node,
5887 StringFromEnvironmentConstantExpression constant, 6277 ConstantExpression constant,
6278 Node rhs,
5888 A arg) { 6279 A arg) {
6280 apply(rhs, arg);
5889 return null; 6281 return null;
5890 } 6282 }
5891 6283
5892 @override 6284 @override
5893 R visitConstructorIncompatibleInvoke( 6285 R visitFinalLocalVariableSetIfNull(
5894 NewExpression node, 6286 Send node,
5895 ConstructorElement constructor, 6287 LocalVariableElement variable,
5896 InterfaceType type, 6288 Node rhs,
5897 NodeList arguments,
5898 CallStructure callStructure,
5899 A arg) { 6289 A arg) {
5900 apply(arguments, arg); 6290 apply(rhs, arg);
5901 return null; 6291 return null;
5902 } 6292 }
5903 6293
5904 @override 6294 @override
5905 R visitUnresolvedClassConstructorInvoke( 6295 R visitFinalParameterSetIfNull(
5906 NewExpression node, 6296 Send node,
5907 Element constructor, 6297 ParameterElement parameter,
5908 DartType type, 6298 Node rhs,
5909 NodeList arguments,
5910 Selector selector,
5911 A arg) { 6299 A arg) {
5912 apply(arguments, arg); 6300 apply(rhs, arg);
5913 return null; 6301 return null;
5914 } 6302 }
5915 6303
5916 @override 6304 @override
5917 R visitUnresolvedConstructorInvoke( 6305 R visitFinalStaticFieldSetIfNull(
5918 NewExpression node, 6306 Send node,
5919 Element constructor, 6307 FieldElement field,
5920 DartType type, 6308 Node rhs,
5921 NodeList arguments,
5922 Selector selector,
5923 A arg) { 6309 A arg) {
5924 apply(arguments, arg); 6310 apply(rhs, arg);
5925 return null; 6311 return null;
5926 } 6312 }
5927 6313
5928 @override 6314 @override
5929 R visitFactoryConstructorInvoke( 6315 R visitFinalSuperFieldSetIfNull(
5930 NewExpression node, 6316 Send node,
5931 ConstructorElement constructor, 6317 FieldElement field,
5932 InterfaceType type, 6318 Node rhs,
5933 NodeList arguments,
5934 CallStructure callStructure,
5935 A arg) { 6319 A arg) {
5936 apply(arguments, arg); 6320 apply(rhs, arg);
5937 return null; 6321 return null;
5938 } 6322 }
5939 6323
5940 @override 6324 @override
5941 R visitGenerativeConstructorInvoke( 6325 R visitFinalTopLevelFieldSetIfNull(
5942 NewExpression node, 6326 Send node,
5943 ConstructorElement constructor, 6327 FieldElement field,
5944 InterfaceType type, 6328 Node rhs,
5945 NodeList arguments,
5946 CallStructure callStructure,
5947 A arg) { 6329 A arg) {
5948 apply(arguments, arg); 6330 apply(rhs, arg);
5949 return null; 6331 return null;
5950 } 6332 }
5951 6333
5952 @override 6334 @override
5953 R visitRedirectingFactoryConstructorInvoke( 6335 R visitIfNotNullDynamicPropertySetIfNull(
5954 NewExpression node, 6336 Send node,
5955 ConstructorElement constructor, 6337 Node receiver,
5956 InterfaceType type, 6338 Name name,
5957 ConstructorElement effectiveTarget, 6339 Node rhs,
5958 InterfaceType effectiveTargetType,
5959 NodeList arguments,
5960 CallStructure callStructure,
5961 A arg) { 6340 A arg) {
5962 apply(arguments, arg); 6341 apply(receiver, arg);
6342 apply(rhs, arg);
5963 return null; 6343 return null;
5964 } 6344 }
5965 6345
5966 @override 6346 @override
5967 R visitRedirectingGenerativeConstructorInvoke( 6347 R visitLocalFunctionSetIfNull(
5968 NewExpression node, 6348 Send node,
5969 ConstructorElement constructor, 6349 LocalFunctionElement function,
5970 InterfaceType type, 6350 Node rhs,
5971 NodeList arguments,
5972 CallStructure callStructure,
5973 A arg) { 6351 A arg) {
5974 apply(arguments, arg); 6352 apply(rhs, arg);
5975 return null; 6353 return null;
5976 } 6354 }
5977 6355
5978 @override 6356 @override
5979 R visitAbstractClassConstructorInvoke( 6357 R visitLocalVariableSetIfNull(
5980 NewExpression node, 6358 Send node,
5981 ConstructorElement element, 6359 LocalVariableElement variable,
5982 InterfaceType type, 6360 Node rhs,
5983 NodeList arguments,
5984 CallStructure callStructure,
5985 A arg) { 6361 A arg) {
5986 apply(arguments, arg); 6362 apply(rhs, arg);
5987 return null; 6363 return null;
5988 } 6364 }
5989 6365
5990 @override 6366 @override
5991 R visitUnresolvedRedirectingFactoryConstructorInvoke( 6367 R visitParameterSetIfNull(
5992 NewExpression node, 6368 Send node,
5993 ConstructorElement constructor, 6369 ParameterElement parameter,
5994 InterfaceType type, 6370 Node rhs,
5995 NodeList arguments,
5996 CallStructure callStructure,
5997 A arg) { 6371 A arg) {
5998 apply(arguments, arg); 6372 apply(rhs, arg);
5999 return null; 6373 return null;
6000 } 6374 }
6001 6375
6002 @override 6376 @override
6003 R errorNonConstantConstructorInvoke( 6377 R visitStaticFieldSetIfNull(
6004 NewExpression node, 6378 Send node,
6005 Element element, 6379 FieldElement field,
6006 DartType type, 6380 Node rhs,
6007 NodeList arguments,
6008 CallStructure callStructure,
6009 A arg) { 6381 A arg) {
6010 apply(arguments, arg); 6382 apply(rhs, arg);
6011 return null; 6383 return null;
6012 } 6384 }
6013 6385
6014 @override 6386 @override
6015 R visitUnresolvedStaticGetterCompound( 6387 R visitStaticGetterSetterSetIfNull(
6016 Send node, 6388 Send node,
6017 Element element, 6389 FunctionElement getter,
6018 MethodElement setter, 6390 FunctionElement setter,
6019 AssignmentOperator operator,
6020 Node rhs, 6391 Node rhs,
6021 A arg) { 6392 A arg) {
6022 apply(rhs, arg); 6393 apply(rhs, arg);
6023 return null; 6394 return null;
6024 } 6395 }
6025 6396
6026 @override 6397 @override
6027 R visitUnresolvedTopLevelGetterCompound( 6398 R visitStaticMethodSetIfNull(
6028 Send node, 6399 Send node,
6029 Element element, 6400 FunctionElement method,
6030 MethodElement setter,
6031 AssignmentOperator operator,
6032 Node rhs, 6401 Node rhs,
6033 A arg) { 6402 A arg) {
6034 apply(rhs, arg); 6403 apply(rhs, arg);
6035 return null; 6404 return null;
6036 } 6405 }
6037 6406
6038 @override 6407 @override
6039 R visitUnresolvedStaticSetterCompound( 6408 R visitStaticMethodSetterSetIfNull(
6040 Send node, 6409 Send node,
6041 MethodElement getter, 6410 MethodElement method,
6042 Element element, 6411 MethodElement setter,
6043 AssignmentOperator operator,
6044 Node rhs, 6412 Node rhs,
6045 A arg) { 6413 A arg) {
6046 apply(rhs, arg); 6414 apply(rhs, arg);
6047 return null; 6415 return null;
6048 } 6416 }
6049 6417
6050 @override 6418 @override
6051 R visitUnresolvedTopLevelSetterCompound( 6419 R visitSuperFieldFieldSetIfNull(
6052 Send node, 6420 Send node,
6053 MethodElement getter, 6421 FieldElement readField,
6054 Element element, 6422 FieldElement writtenField,
6055 AssignmentOperator operator,
6056 Node rhs, 6423 Node rhs,
6057 A arg) { 6424 A arg) {
6058 apply(rhs, arg); 6425 apply(rhs, arg);
6059 return null; 6426 return null;
6060 } 6427 }
6061 6428
6062 @override 6429 @override
6063 R visitStaticMethodCompound( 6430 R visitSuperFieldSetIfNull(
6064 Send node, 6431 Send node,
6065 MethodElement method, 6432 FieldElement field,
6066 AssignmentOperator operator,
6067 Node rhs, 6433 Node rhs,
6068 A arg) { 6434 A arg) {
6069 apply(rhs, arg); 6435 apply(rhs, arg);
6070 return null; 6436 return null;
6071 } 6437 }
6072 6438
6073 @override 6439 @override
6074 R visitUnresolvedStaticGetterPrefix( 6440 R visitSuperFieldSetterSetIfNull(
6441 Send node,
6442 FieldElement field,
6443 FunctionElement setter,
6444 Node rhs,
6445 A arg) {
6446 apply(rhs, arg);
6447 return null;
6448 }
6449
6450 @override
6451 R visitSuperGetterFieldSetIfNull(
6452 Send node,
6453 FunctionElement getter,
6454 FieldElement field,
6455 Node rhs,
6456 A arg) {
6457 apply(rhs, arg);
6458 return null;
6459 }
6460
6461 @override
6462 R visitSuperGetterSetterSetIfNull(
6463 Send node,
6464 FunctionElement getter,
6465 FunctionElement setter,
6466 Node rhs,
6467 A arg) {
6468 apply(rhs, arg);
6469 return null;
6470 }
6471
6472 @override
6473 R visitSuperMethodSetIfNull(
6474 Send node,
6475 FunctionElement method,
6476 Node rhs,
6477 A arg) {
6478 apply(rhs, arg);
6479 return null;
6480 }
6481
6482 @override
6483 R visitSuperMethodSetterSetIfNull(
6484 Send node,
6485 FunctionElement method,
6486 FunctionElement setter,
6487 Node rhs,
6488 A arg) {
6489 apply(rhs, arg);
6490 return null;
6491 }
6492
6493 @override
6494 R visitThisPropertySetIfNull(
6495 Send node,
6496 Name name,
6497 Node rhs,
6498 A arg) {
6499 apply(rhs, arg);
6500 return null;
6501 }
6502
6503 @override
6504 R visitTopLevelFieldSetIfNull(
6505 Send node,
6506 FieldElement field,
6507 Node rhs,
6508 A arg) {
6509 apply(rhs, arg);
6510 return null;
6511 }
6512
6513 @override
6514 R visitTopLevelGetterSetterSetIfNull(
6515 Send node,
6516 FunctionElement getter,
6517 FunctionElement setter,
6518 Node rhs,
6519 A arg) {
6520 apply(rhs, arg);
6521 return null;
6522 }
6523
6524 @override
6525 R visitTopLevelMethodSetIfNull(
6526 Send node,
6527 FunctionElement method,
6528 Node rhs,
6529 A arg) {
6530 apply(rhs, arg);
6531 return null;
6532 }
6533
6534 @override
6535 R visitTopLevelMethodSetterSetIfNull(
6536 Send node,
6537 FunctionElement method,
6538 FunctionElement setter,
6539 Node rhs,
6540 A arg) {
6541 apply(rhs, arg);
6542 return null;
6543 }
6544
6545 @override
6546 R visitTypeVariableTypeLiteralSetIfNull(
6547 Send node,
6548 TypeVariableElement element,
6549 Node rhs,
6550 A arg) {
6551 apply(rhs, arg);
6552 return null;
6553 }
6554
6555 @override
6556 R visitTypedefTypeLiteralSetIfNull(
6557 Send node,
6558 ConstantExpression constant,
6559 Node rhs,
6560 A arg) {
6561 apply(rhs, arg);
6562 return null;
6563 }
6564
6565 @override
6566 R visitUnresolvedSetIfNull(
6567 Send node,
6568 Element element,
6569 Node rhs,
6570 A arg) {
6571 apply(rhs, arg);
6572 return null;
6573 }
6574
6575 @override
6576 R visitUnresolvedStaticGetterSetIfNull(
6075 Send node, 6577 Send node,
6076 Element element, 6578 Element element,
6077 MethodElement setter, 6579 MethodElement setter,
6078 IncDecOperator operator, 6580 Node rhs,
6079 A arg) { 6581 A arg) {
6080 return null; 6582 apply(rhs, arg);
6081 } 6583 return null;
6082 6584 }
6083 @override 6585
6084 R visitUnresolvedTopLevelGetterPrefix( 6586 @override
6587 R visitUnresolvedStaticSetterSetIfNull(
6588 Send node,
6589 MethodElement getter,
6590 Element element,
6591 Node rhs,
6592 A arg) {
6593 apply(rhs, arg);
6594 return null;
6595 }
6596
6597 @override
6598 R visitUnresolvedSuperGetterSetIfNull(
6085 Send node, 6599 Send node,
6086 Element element, 6600 Element element,
6087 MethodElement setter, 6601 MethodElement setter,
6088 IncDecOperator operator, 6602 Node rhs,
6089 A arg) { 6603 A arg) {
6090 return null; 6604 apply(rhs, arg);
6091 } 6605 return null;
6092 6606 }
6093 @override 6607
6094 R visitUnresolvedStaticSetterPrefix( 6608 @override
6609 R visitUnresolvedSuperSetIfNull(
6610 Send node,
6611 Element element,
6612 Node rhs,
6613 A arg) {
6614 apply(rhs, arg);
6615 return null;
6616 }
6617
6618 @override
6619 R visitUnresolvedSuperSetterSetIfNull(
6095 Send node, 6620 Send node,
6096 MethodElement getter, 6621 MethodElement getter,
6097 Element element, 6622 Element element,
6098 IncDecOperator operator, 6623 Node rhs,
6099 A arg) { 6624 A arg) {
6100 return null; 6625 apply(rhs, arg);
6101 } 6626 return null;
6102 6627 }
6103 @override 6628
6104 R visitUnresolvedTopLevelSetterPrefix( 6629 @override
6105 Send node, 6630 R visitUnresolvedTopLevelGetterSetIfNull(
6106 MethodElement getter,
6107 Element element,
6108 IncDecOperator operator,
6109 A arg) {
6110 return null;
6111 }
6112
6113 @override
6114 R visitStaticMethodPrefix(
6115 Send node,
6116 MethodElement method,
6117 IncDecOperator operator,
6118 A arg) {
6119 return null;
6120 }
6121
6122 @override
6123 R visitTopLevelMethodPrefix(
6124 Send node,
6125 MethodElement method,
6126 IncDecOperator operator,
6127 A arg) {
6128 return null;
6129 }
6130
6131 @override
6132 R visitUnresolvedStaticGetterPostfix(
6133 Send node, 6631 Send node,
6134 Element element, 6632 Element element,
6135 MethodElement setter, 6633 MethodElement setter,
6136 IncDecOperator operator, 6634 Node rhs,
6137 A arg) { 6635 A arg) {
6138 return null; 6636 apply(rhs, arg);
6139 }
6140
6141 @override
6142 R visitUnresolvedTopLevelGetterPostfix(
6143 Send node,
6144 Element element,
6145 MethodElement setter,
6146 IncDecOperator operator,
6147 A arg) {
6148 return null;
6149 }
6150
6151 @override
6152 R visitUnresolvedStaticSetterPostfix(
6153 Send node,
6154 MethodElement getter,
6155 Element element,
6156 IncDecOperator operator,
6157 A arg) {
6158 return null;
6159 }
6160
6161 @override
6162 R visitUnresolvedTopLevelSetterPostfix(
6163 Send node,
6164 MethodElement getter,
6165 Element element,
6166 IncDecOperator operator,
6167 A arg) {
6168 return null;
6169 }
6170
6171 @override
6172 R visitStaticMethodPostfix(
6173 Send node,
6174 MethodElement method,
6175 IncDecOperator operator,
6176 A arg) {
6177 return null;
6178 }
6179
6180 @override
6181 R visitTopLevelMethodPostfix(
6182 Send node,
6183 MethodElement method,
6184 IncDecOperator operator,
6185 A arg) {
6186 return null;
6187 }
6188
6189 @override
6190 R visitFinalLocalVariablePostfix(
6191 Send node,
6192 LocalVariableElement variable,
6193 IncDecOperator operator,
6194 A arg) {
6195 return null;
6196 }
6197
6198 @override
6199 R visitFinalLocalVariablePrefix(
6200 Send node,
6201 LocalVariableElement variable,
6202 IncDecOperator operator,
6203 A arg) {
6204 return null;
6205 }
6206
6207 @override
6208 R visitFinalParameterPostfix(
6209 Send node,
6210 ParameterElement parameter,
6211 IncDecOperator operator,
6212 A arg) {
6213 return null;
6214 }
6215
6216 @override
6217 R visitFinalParameterPrefix(
6218 Send node,
6219 ParameterElement parameter,
6220 IncDecOperator operator,
6221 A arg) {
6222 return null;
6223 }
6224
6225 @override
6226 R visitFinalStaticFieldPostfix(
6227 Send node,
6228 FieldElement field,
6229 IncDecOperator operator,
6230 A arg) {
6231 return null;
6232 }
6233
6234 @override
6235 R visitFinalStaticFieldPrefix(
6236 Send node,
6237 FieldElement field,
6238 IncDecOperator operator,
6239 A arg) {
6240 return null;
6241 }
6242
6243 @override
6244 R visitSuperFieldFieldCompound(
6245 Send node, FieldElement readField,
6246 FieldElement writtenField,
6247 AssignmentOperator operator,
6248 Node rhs,
6249 A arg) {
6250 apply(rhs, arg);
6251 return null; 6637 return null;
6252 } 6638 }
6253 6639
6254 @override 6640 @override
6255 R visitFinalSuperFieldCompound( 6641 R visitUnresolvedTopLevelSetterSetIfNull(
6256 Send node, 6642 Send node,
6257 FieldElement field, 6643 MethodElement getter,
6258 AssignmentOperator operator, 6644 Element element,
6259 Node rhs, 6645 Node rhs,
6260 A arg) { 6646 A arg) {
6261 apply(rhs, arg); 6647 apply(rhs, arg);
6262 return null; 6648 return null;
6263 } 6649 }
6264 6650
6265 @override 6651 @override
6266 R visitFinalSuperFieldPostfix( 6652 R visitConstConstructorInvoke(
6267 Send node, 6653 NewExpression node,
6268 FieldElement field, 6654 ConstructedConstantExpression constant,
6269 IncDecOperator operator,
6270 A arg) { 6655 A arg) {
6271 return null; 6656 return null;
6272 } 6657 }
6273 6658
6274 @override 6659 @override
6275 R visitFinalSuperFieldPrefix( 6660 R visitBoolFromEnvironmentConstructorInvoke(
6276 Send node, 6661 NewExpression node,
6277 FieldElement field, 6662 BoolFromEnvironmentConstantExpression constant,
6278 IncDecOperator operator,
6279 A arg) { 6663 A arg) {
6280 return null; 6664 return null;
6281 } 6665 }
6282 6666
6283 @override 6667 @override
6284 R visitSuperMethodCompound( 6668 R visitIntFromEnvironmentConstructorInvoke(
6285 Send node, 6669 NewExpression node,
6286 FunctionElement method, 6670 IntFromEnvironmentConstantExpression constant,
6287 AssignmentOperator operator,
6288 Node rhs,
6289 A arg) {
6290 apply(rhs, arg);
6291 return null;
6292 }
6293
6294 @override
6295 R visitSuperMethodPostfix(
6296 Send node,
6297 FunctionElement method,
6298 IncDecOperator operator,
6299 A arg) { 6671 A arg) {
6300 return null; 6672 return null;
6301 } 6673 }
6302 6674
6303 @override 6675 @override
6304 R visitSuperMethodPrefix( 6676 R visitStringFromEnvironmentConstructorInvoke(
6305 Send node, 6677 NewExpression node,
6306 FunctionElement method, 6678 StringFromEnvironmentConstantExpression constant,
6307 IncDecOperator operator,
6308 A arg) { 6679 A arg) {
6309 return null; 6680 return null;
6310 } 6681 }
6311 6682
6312 @override 6683 @override
6313 R visitFinalTopLevelFieldPostfix( 6684 R visitConstructorIncompatibleInvoke(
6314 Send node, 6685 NewExpression node,
6315 FieldElement field, 6686 ConstructorElement constructor,
6316 IncDecOperator operator, 6687 InterfaceType type,
6688 NodeList arguments,
6689 CallStructure callStructure,
6317 A arg) { 6690 A arg) {
6691 apply(arguments, arg);
6318 return null; 6692 return null;
6319 } 6693 }
6320 6694
6321 @override 6695 @override
6322 R visitFinalTopLevelFieldPrefix( 6696 R visitUnresolvedClassConstructorInvoke(
6323 Send node, 6697 NewExpression node,
6324 FieldElement field, 6698 Element constructor,
6325 IncDecOperator operator, 6699 DartType type,
6700 NodeList arguments,
6701 Selector selector,
6326 A arg) { 6702 A arg) {
6703 apply(arguments, arg);
6327 return null; 6704 return null;
6328 } 6705 }
6329 6706
6330 @override 6707 @override
6331 R visitTopLevelMethodCompound( 6708 R visitUnresolvedConstructorInvoke(
6709 NewExpression node,
6710 Element constructor,
6711 DartType type,
6712 NodeList arguments,
6713 Selector selector,
6714 A arg) {
6715 apply(arguments, arg);
6716 return null;
6717 }
6718
6719 @override
6720 R visitFactoryConstructorInvoke(
6721 NewExpression node,
6722 ConstructorElement constructor,
6723 InterfaceType type,
6724 NodeList arguments,
6725 CallStructure callStructure,
6726 A arg) {
6727 apply(arguments, arg);
6728 return null;
6729 }
6730
6731 @override
6732 R visitGenerativeConstructorInvoke(
6733 NewExpression node,
6734 ConstructorElement constructor,
6735 InterfaceType type,
6736 NodeList arguments,
6737 CallStructure callStructure,
6738 A arg) {
6739 apply(arguments, arg);
6740 return null;
6741 }
6742
6743 @override
6744 R visitRedirectingFactoryConstructorInvoke(
6745 NewExpression node,
6746 ConstructorElement constructor,
6747 InterfaceType type,
6748 ConstructorElement effectiveTarget,
6749 InterfaceType effectiveTargetType,
6750 NodeList arguments,
6751 CallStructure callStructure,
6752 A arg) {
6753 apply(arguments, arg);
6754 return null;
6755 }
6756
6757 @override
6758 R visitRedirectingGenerativeConstructorInvoke(
6759 NewExpression node,
6760 ConstructorElement constructor,
6761 InterfaceType type,
6762 NodeList arguments,
6763 CallStructure callStructure,
6764 A arg) {
6765 apply(arguments, arg);
6766 return null;
6767 }
6768
6769 @override
6770 R visitAbstractClassConstructorInvoke(
6771 NewExpression node,
6772 ConstructorElement element,
6773 InterfaceType type,
6774 NodeList arguments,
6775 CallStructure callStructure,
6776 A arg) {
6777 apply(arguments, arg);
6778 return null;
6779 }
6780
6781 @override
6782 R visitUnresolvedRedirectingFactoryConstructorInvoke(
6783 NewExpression node,
6784 ConstructorElement constructor,
6785 InterfaceType type,
6786 NodeList arguments,
6787 CallStructure callStructure,
6788 A arg) {
6789 apply(arguments, arg);
6790 return null;
6791 }
6792
6793 @override
6794 R errorNonConstantConstructorInvoke(
6795 NewExpression node,
6796 Element element,
6797 DartType type,
6798 NodeList arguments,
6799 CallStructure callStructure,
6800 A arg) {
6801 apply(arguments, arg);
6802 return null;
6803 }
6804
6805 @override
6806 R visitUnresolvedStaticGetterCompound(
6332 Send node, 6807 Send node,
6333 FunctionElement method, 6808 Element element,
6809 MethodElement setter,
6334 AssignmentOperator operator, 6810 AssignmentOperator operator,
6335 Node rhs, 6811 Node rhs,
6336 A arg) { 6812 A arg) {
6337 apply(rhs, arg); 6813 apply(rhs, arg);
6338 return null; 6814 return null;
6339 } 6815 }
6340 6816
6341 @override 6817 @override
6342 R visitUnresolvedSuperCompound( 6818 R visitUnresolvedTopLevelGetterCompound(
6343 Send node, 6819 Send node,
6344 Element element, 6820 Element element,
6821 MethodElement setter,
6345 AssignmentOperator operator, 6822 AssignmentOperator operator,
6346 Node rhs, 6823 Node rhs,
6347 A arg) { 6824 A arg) {
6348 apply(rhs, arg); 6825 apply(rhs, arg);
6349 return null; 6826 return null;
6350 } 6827 }
6351 6828
6352 @override 6829 @override
6353 R visitUnresolvedSuperPostfix( 6830 R visitUnresolvedStaticSetterCompound(
6354 Send node, 6831 Send node,
6832 MethodElement getter,
6355 Element element, 6833 Element element,
6356 IncDecOperator operator, 6834 AssignmentOperator operator,
6835 Node rhs,
6357 A arg) { 6836 A arg) {
6837 apply(rhs, arg);
6358 return null; 6838 return null;
6359 } 6839 }
6360 6840
6361 @override 6841 @override
6362 R visitUnresolvedSuperPrefix( 6842 R visitUnresolvedTopLevelSetterCompound(
6363 Send node, 6843 Send node,
6844 MethodElement getter,
6364 Element element, 6845 Element element,
6365 IncDecOperator operator, 6846 AssignmentOperator operator,
6847 Node rhs,
6366 A arg) { 6848 A arg) {
6849 apply(rhs, arg);
6367 return null; 6850 return null;
6368 } 6851 }
6369 6852
6370 @override 6853 @override
6371 R visitUnresolvedSuperGetterCompound( 6854 R visitStaticMethodCompound(
6372 Send node, Element element, 6855 Send node,
6373 MethodElement setter, 6856 MethodElement method,
6374 AssignmentOperator operator, 6857 AssignmentOperator operator,
6375 Node rhs, 6858 Node rhs,
6376 A arg) { 6859 A arg) {
6377 apply(rhs, arg); 6860 apply(rhs, arg);
6378 return null; 6861 return null;
6379 } 6862 }
6380 6863
6381 @override 6864 @override
6382 R visitUnresolvedSuperGetterPostfix( 6865 R visitUnresolvedStaticGetterPrefix(
6383 Send node, 6866 Send node,
6384 Element element, 6867 Element element,
6385 MethodElement setter, 6868 MethodElement setter,
6386 IncDecOperator operator, 6869 IncDecOperator operator,
6387 A arg) { 6870 A arg) {
6388 return null; 6871 return null;
6389 } 6872 }
6390 6873
6391 @override 6874 @override
6392 R visitUnresolvedSuperGetterPrefix( 6875 R visitUnresolvedTopLevelGetterPrefix(
6393 Send node, 6876 Send node,
6394 Element element, 6877 Element element,
6395 MethodElement setter, 6878 MethodElement setter,
6396 IncDecOperator operator, 6879 IncDecOperator operator,
6397 A arg) { 6880 A arg) {
6398 return null; 6881 return null;
6399 } 6882 }
6400 6883
6401 @override 6884 @override
6402 R visitUnresolvedSuperSetterCompound( 6885 R visitUnresolvedStaticSetterPrefix(
6403 Send node, MethodElement getter, 6886 Send node,
6887 MethodElement getter,
6404 Element element, 6888 Element element,
6405 AssignmentOperator operator, 6889 IncDecOperator operator,
6406 Node rhs,
6407 A arg) { 6890 A arg) {
6408 apply(rhs, arg);
6409 return null; 6891 return null;
6410 } 6892 }
6411 6893
6412 @override 6894 @override
6413 R visitUnresolvedSuperSetterPostfix( 6895 R visitUnresolvedTopLevelSetterPrefix(
6414 Send node, 6896 Send node,
6415 MethodElement getter, 6897 MethodElement getter,
6416 Element element, 6898 Element element,
6417 IncDecOperator operator, 6899 IncDecOperator operator,
6418 A arg) { 6900 A arg) {
6419 return null; 6901 return null;
6420 } 6902 }
6421 6903
6422 @override 6904 @override
6905 R visitStaticMethodPrefix(
6906 Send node,
6907 MethodElement method,
6908 IncDecOperator operator,
6909 A arg) {
6910 return null;
6911 }
6912
6913 @override
6914 R visitTopLevelMethodPrefix(
6915 Send node,
6916 MethodElement method,
6917 IncDecOperator operator,
6918 A arg) {
6919 return null;
6920 }
6921
6922 @override
6923 R visitUnresolvedStaticGetterPostfix(
6924 Send node,
6925 Element element,
6926 MethodElement setter,
6927 IncDecOperator operator,
6928 A arg) {
6929 return null;
6930 }
6931
6932 @override
6933 R visitUnresolvedTopLevelGetterPostfix(
6934 Send node,
6935 Element element,
6936 MethodElement setter,
6937 IncDecOperator operator,
6938 A arg) {
6939 return null;
6940 }
6941
6942 @override
6943 R visitUnresolvedStaticSetterPostfix(
6944 Send node,
6945 MethodElement getter,
6946 Element element,
6947 IncDecOperator operator,
6948 A arg) {
6949 return null;
6950 }
6951
6952 @override
6953 R visitUnresolvedTopLevelSetterPostfix(
6954 Send node,
6955 MethodElement getter,
6956 Element element,
6957 IncDecOperator operator,
6958 A arg) {
6959 return null;
6960 }
6961
6962 @override
6963 R visitStaticMethodPostfix(
6964 Send node,
6965 MethodElement method,
6966 IncDecOperator operator,
6967 A arg) {
6968 return null;
6969 }
6970
6971 @override
6972 R visitTopLevelMethodPostfix(
6973 Send node,
6974 MethodElement method,
6975 IncDecOperator operator,
6976 A arg) {
6977 return null;
6978 }
6979
6980 @override
6981 R visitFinalLocalVariablePostfix(
6982 Send node,
6983 LocalVariableElement variable,
6984 IncDecOperator operator,
6985 A arg) {
6986 return null;
6987 }
6988
6989 @override
6990 R visitFinalLocalVariablePrefix(
6991 Send node,
6992 LocalVariableElement variable,
6993 IncDecOperator operator,
6994 A arg) {
6995 return null;
6996 }
6997
6998 @override
6999 R visitFinalParameterPostfix(
7000 Send node,
7001 ParameterElement parameter,
7002 IncDecOperator operator,
7003 A arg) {
7004 return null;
7005 }
7006
7007 @override
7008 R visitFinalParameterPrefix(
7009 Send node,
7010 ParameterElement parameter,
7011 IncDecOperator operator,
7012 A arg) {
7013 return null;
7014 }
7015
7016 @override
7017 R visitFinalStaticFieldPostfix(
7018 Send node,
7019 FieldElement field,
7020 IncDecOperator operator,
7021 A arg) {
7022 return null;
7023 }
7024
7025 @override
7026 R visitFinalStaticFieldPrefix(
7027 Send node,
7028 FieldElement field,
7029 IncDecOperator operator,
7030 A arg) {
7031 return null;
7032 }
7033
7034 @override
7035 R visitSuperFieldFieldCompound(
7036 Send node, FieldElement readField,
7037 FieldElement writtenField,
7038 AssignmentOperator operator,
7039 Node rhs,
7040 A arg) {
7041 apply(rhs, arg);
7042 return null;
7043 }
7044
7045 @override
7046 R visitFinalSuperFieldCompound(
7047 Send node,
7048 FieldElement field,
7049 AssignmentOperator operator,
7050 Node rhs,
7051 A arg) {
7052 apply(rhs, arg);
7053 return null;
7054 }
7055
7056 @override
7057 R visitFinalSuperFieldPostfix(
7058 Send node,
7059 FieldElement field,
7060 IncDecOperator operator,
7061 A arg) {
7062 return null;
7063 }
7064
7065 @override
7066 R visitFinalSuperFieldPrefix(
7067 Send node,
7068 FieldElement field,
7069 IncDecOperator operator,
7070 A arg) {
7071 return null;
7072 }
7073
7074 @override
7075 R visitSuperMethodCompound(
7076 Send node,
7077 FunctionElement method,
7078 AssignmentOperator operator,
7079 Node rhs,
7080 A arg) {
7081 apply(rhs, arg);
7082 return null;
7083 }
7084
7085 @override
7086 R visitSuperMethodPostfix(
7087 Send node,
7088 FunctionElement method,
7089 IncDecOperator operator,
7090 A arg) {
7091 return null;
7092 }
7093
7094 @override
7095 R visitSuperMethodPrefix(
7096 Send node,
7097 FunctionElement method,
7098 IncDecOperator operator,
7099 A arg) {
7100 return null;
7101 }
7102
7103 @override
7104 R visitFinalTopLevelFieldPostfix(
7105 Send node,
7106 FieldElement field,
7107 IncDecOperator operator,
7108 A arg) {
7109 return null;
7110 }
7111
7112 @override
7113 R visitFinalTopLevelFieldPrefix(
7114 Send node,
7115 FieldElement field,
7116 IncDecOperator operator,
7117 A arg) {
7118 return null;
7119 }
7120
7121 @override
7122 R visitTopLevelMethodCompound(
7123 Send node,
7124 FunctionElement method,
7125 AssignmentOperator operator,
7126 Node rhs,
7127 A arg) {
7128 apply(rhs, arg);
7129 return null;
7130 }
7131
7132 @override
7133 R visitUnresolvedSuperCompound(
7134 Send node,
7135 Element element,
7136 AssignmentOperator operator,
7137 Node rhs,
7138 A arg) {
7139 apply(rhs, arg);
7140 return null;
7141 }
7142
7143 @override
7144 R visitUnresolvedSuperPostfix(
7145 Send node,
7146 Element element,
7147 IncDecOperator operator,
7148 A arg) {
7149 return null;
7150 }
7151
7152 @override
7153 R visitUnresolvedSuperPrefix(
7154 Send node,
7155 Element element,
7156 IncDecOperator operator,
7157 A arg) {
7158 return null;
7159 }
7160
7161 @override
7162 R visitUnresolvedSuperGetterCompound(
7163 Send node, Element element,
7164 MethodElement setter,
7165 AssignmentOperator operator,
7166 Node rhs,
7167 A arg) {
7168 apply(rhs, arg);
7169 return null;
7170 }
7171
7172 @override
7173 R visitUnresolvedSuperGetterPostfix(
7174 Send node,
7175 Element element,
7176 MethodElement setter,
7177 IncDecOperator operator,
7178 A arg) {
7179 return null;
7180 }
7181
7182 @override
7183 R visitUnresolvedSuperGetterPrefix(
7184 Send node,
7185 Element element,
7186 MethodElement setter,
7187 IncDecOperator operator,
7188 A arg) {
7189 return null;
7190 }
7191
7192 @override
7193 R visitUnresolvedSuperSetterCompound(
7194 Send node, MethodElement getter,
7195 Element element,
7196 AssignmentOperator operator,
7197 Node rhs,
7198 A arg) {
7199 apply(rhs, arg);
7200 return null;
7201 }
7202
7203 @override
7204 R visitUnresolvedSuperSetterPostfix(
7205 Send node,
7206 MethodElement getter,
7207 Element element,
7208 IncDecOperator operator,
7209 A arg) {
7210 return null;
7211 }
7212
7213 @override
6423 R visitUnresolvedSuperSetterPrefix( 7214 R visitUnresolvedSuperSetterPrefix(
6424 Send node, 7215 Send node,
6425 MethodElement getter, 7216 MethodElement getter,
6426 Element element, 7217 Element element,
6427 IncDecOperator operator, 7218 IncDecOperator operator,
6428 A arg) { 7219 A arg) {
6429 return null; 7220 return null;
6430 } 7221 }
6431 } 7222 }
6432 7223
(...skipping 17 matching lines...) Expand all
6450 "TraversalMixin.applyParameters unimplemented"); 7241 "TraversalMixin.applyParameters unimplemented");
6451 } 7242 }
6452 7243
6453 @override 7244 @override
6454 R visitAbstractMethodDeclaration( 7245 R visitAbstractMethodDeclaration(
6455 FunctionExpression node, 7246 FunctionExpression node,
6456 MethodElement method, 7247 MethodElement method,
6457 NodeList parameters, 7248 NodeList parameters,
6458 A arg) { 7249 A arg) {
6459 applyParameters(parameters, arg); 7250 applyParameters(parameters, arg);
6460 return null;
6461 }
6462
6463 @override
6464 R visitClosureDeclaration(
6465 FunctionExpression node,
6466 LocalFunctionElement function,
6467 NodeList parameters,
6468 Node body,
6469 A arg) {
6470 applyParameters(parameters, arg);
6471 apply(body, arg);
6472 return null;
6473 }
6474
6475 @override
6476 R visitFactoryConstructorDeclaration(
6477 FunctionExpression node,
6478 ConstructorElement constructor,
6479 NodeList parameters,
6480 Node body,
6481 A arg) {
6482 applyParameters(parameters, arg);
6483 apply(body, arg);
6484 return null;
6485 }
6486
6487 @override
6488 R visitFieldInitializer(
6489 SendSet node,
6490 FieldElement field,
6491 Node initializer,
6492 A arg) {
6493 apply(initializer, arg);
6494 return null;
6495 }
6496
6497 @override
6498 R visitGenerativeConstructorDeclaration(
6499 FunctionExpression node,
6500 ConstructorElement constructor,
6501 NodeList parameters,
6502 NodeList initializers,
6503 Node body,
6504 A arg) {
6505 applyParameters(parameters, arg);
6506 applyInitializers(node, arg);
6507 apply(body, arg);
6508 return null;
6509 }
6510
6511 @override
6512 R visitInstanceMethodDeclaration(
6513 FunctionExpression node,
6514 MethodElement method,
6515 NodeList parameters,
6516 Node body,
6517 A arg) {
6518 applyParameters(parameters, arg);
6519 apply(body, arg);
6520 return null;
6521 }
6522
6523 @override
6524 R visitLocalFunctionDeclaration(
6525 FunctionExpression node,
6526 LocalFunctionElement function,
6527 NodeList parameters,
6528 Node body,
6529 A arg) {
6530 applyParameters(parameters, arg);
6531 apply(body, arg);
6532 return null;
6533 }
6534
6535 @override
6536 R visitRedirectingFactoryConstructorDeclaration(
6537 FunctionExpression node,
6538 ConstructorElement constructor,
6539 NodeList parameters,
6540 InterfaceType redirectionType,
6541 ConstructorElement redirectionTarget,
6542 A arg) {
6543 applyParameters(parameters, arg);
6544 return null;
6545 }
6546
6547 @override
6548 R visitRedirectingGenerativeConstructorDeclaration(
6549 FunctionExpression node,
6550 ConstructorElement constructor,
6551 NodeList parameters,
6552 NodeList initializers,
6553 A arg) {
6554 applyParameters(parameters, arg);
6555 applyInitializers(node, arg);
6556 return null;
6557 }
6558
6559 @override
6560 R visitStaticFunctionDeclaration(
6561 FunctionExpression node,
6562 MethodElement function,
6563 NodeList parameters,
6564 Node body,
6565 A arg) {
6566 applyParameters(parameters, arg);
6567 apply(body, arg);
6568 return null;
6569 }
6570
6571 @override
6572 R visitSuperConstructorInvoke(
6573 Send node,
6574 ConstructorElement superConstructor,
6575 InterfaceType type,
6576 NodeList arguments,
6577 CallStructure callStructure,
6578 A arg) {
6579 apply(arguments, arg);
6580 return null;
6581 }
6582
6583 @override
6584 R visitImplicitSuperConstructorInvoke(
6585 FunctionExpression node,
6586 ConstructorElement superConstructor,
6587 InterfaceType type,
6588 A arg) {
6589 return null;
6590 }
6591
6592 @override
6593 R visitThisConstructorInvoke(
6594 Send node,
6595 ConstructorElement thisConstructor,
6596 NodeList arguments,
6597 CallStructure callStructure,
6598 A arg) {
6599 apply(arguments, arg);
6600 return null;
6601 }
6602
6603 @override
6604 R visitTopLevelFunctionDeclaration(
6605 FunctionExpression node,
6606 MethodElement function,
6607 NodeList parameters,
6608 Node body,
6609 A arg) {
6610 applyParameters(parameters, arg);
6611 apply(body, arg);
6612 return null;
6613 }
6614
6615 @override
6616 R errorUnresolvedFieldInitializer(
6617 SendSet node,
6618 Element element,
6619 Node initializer,
6620 A arg) {
6621 apply(initializer, arg);
6622 return null;
6623 }
6624
6625 @override
6626 R errorUnresolvedSuperConstructorInvoke(
6627 Send node,
6628 Element element,
6629 NodeList arguments,
6630 Selector selector,
6631 A arg) {
6632 apply(arguments, arg);
6633 return null;
6634 }
6635
6636 @override
6637 R errorUnresolvedThisConstructorInvoke(
6638 Send node,
6639 Element element,
6640 NodeList arguments,
6641 Selector selector,
6642 A arg) {
6643 apply(arguments, arg);
6644 return null;
6645 }
6646
6647 @override
6648 R visitLocalVariableDeclaration(
6649 VariableDefinitions node,
6650 Node definition,
6651 LocalVariableElement variable,
6652 Node initializer,
6653 A arg) {
6654 if (initializer != null) {
6655 apply(initializer, arg);
6656 }
6657 return null;
6658 }
6659
6660 @override
6661 R visitOptionalParameterDeclaration(
6662 VariableDefinitions node,
6663 Node definition,
6664 ParameterElement parameter,
6665 ConstantExpression defaultValue,
6666 int index,
6667 A arg) {
6668 return null;
6669 }
6670
6671 @override
6672 R visitParameterDeclaration(
6673 VariableDefinitions node,
6674 Node definition,
6675 ParameterElement parameter,
6676 int index,
6677 A arg) {
6678 return null;
6679 }
6680
6681 @override
6682 R visitInitializingFormalDeclaration(
6683 VariableDefinitions node,
6684 Node definition,
6685 InitializingFormalElement initializingFormal,
6686 int index,
6687 A arg) {
6688 return null;
6689 }
6690
6691 @override
6692 R visitLocalConstantDeclaration(
6693 VariableDefinitions node,
6694 Node definition,
6695 LocalVariableElement variable,
6696 ConstantExpression constant,
6697 A arg) {
6698 return null;
6699 }
6700
6701 @override
6702 R visitNamedInitializingFormalDeclaration(
6703 VariableDefinitions node,
6704 Node definition,
6705 InitializingFormalElement initializingFormal,
6706 ConstantExpression defaultValue,
6707 A arg) {
6708 return null;
6709 }
6710
6711 @override
6712 R visitNamedParameterDeclaration(
6713 VariableDefinitions node,
6714 Node definition,
6715 ParameterElement parameter,
6716 ConstantExpression defaultValue,
6717 A arg) {
6718 return null;
6719 }
6720
6721 @override
6722 R visitOptionalInitializingFormalDeclaration(
6723 VariableDefinitions node,
6724 Node definition,
6725 InitializingFormalElement initializingFormal,
6726 ConstantExpression defaultValue,
6727 int index,
6728 A arg) {
6729 return null;
6730 }
6731
6732 @override
6733 R visitInstanceFieldDeclaration(
6734 VariableDefinitions node,
6735 Node definition,
6736 FieldElement field,
6737 Node initializer,
6738 A arg) {
6739 if (initializer != null) {
6740 apply(initializer, arg);
6741 }
6742 return null;
6743 }
6744
6745 @override
6746 R visitStaticConstantDeclaration(
6747 VariableDefinitions node,
6748 Node definition,
6749 FieldElement field,
6750 ConstantExpression constant,
6751 A arg) {
6752 return null;
6753 }
6754
6755 @override
6756 R visitStaticFieldDeclaration(
6757 VariableDefinitions node,
6758 Node definition,
6759 FieldElement field,
6760 Node initializer,
6761 A arg) {
6762 if (initializer != null) {
6763 apply(initializer, arg);
6764 }
6765 return null;
6766 }
6767
6768 @override
6769 R visitTopLevelConstantDeclaration(
6770 VariableDefinitions node,
6771 Node definition,
6772 FieldElement field,
6773 ConstantExpression constant,
6774 A arg) {
6775 return null;
6776 }
6777
6778 @override
6779 R visitTopLevelFieldDeclaration(
6780 VariableDefinitions node,
6781 Node definition,
6782 FieldElement field,
6783 Node initializer,
6784 A arg) {
6785 if (initializer != null) {
6786 apply(initializer, arg);
6787 }
6788 return null;
6789 }
6790
6791 @override
6792 R visitAbstractGetterDeclaration(
6793 FunctionExpression node,
6794 MethodElement getter,
6795 A arg) {
6796 return null;
6797 }
6798
6799 @override
6800 R visitAbstractSetterDeclaration(
6801 FunctionExpression node,
6802 MethodElement setter,
6803 NodeList parameters,
6804 A arg) {
6805 applyParameters(parameters, arg);
6806 return null; 7251 return null;
6807 } 7252 }
6808 7253
6809 @override 7254 @override
6810 R visitInstanceGetterDeclaration( 7255 R visitClosureDeclaration(
6811 FunctionExpression node, 7256 FunctionExpression node,
6812 MethodElement getter, 7257 LocalFunctionElement function,
7258 NodeList parameters,
6813 Node body, 7259 Node body,
6814 A arg) { 7260 A arg) {
7261 applyParameters(parameters, arg);
6815 apply(body, arg); 7262 apply(body, arg);
6816 return null; 7263 return null;
6817 } 7264 }
6818 7265
6819 @override 7266 @override
6820 R visitInstanceSetterDeclaration( 7267 R visitFactoryConstructorDeclaration(
6821 FunctionExpression node, 7268 FunctionExpression node,
6822 MethodElement setter, 7269 ConstructorElement constructor,
6823 NodeList parameters, 7270 NodeList parameters,
6824 Node body, 7271 Node body,
6825 A arg) { 7272 A arg) {
6826 applyParameters(parameters, arg); 7273 applyParameters(parameters, arg);
6827 apply(body, arg); 7274 apply(body, arg);
6828 return null; 7275 return null;
6829 } 7276 }
6830 7277
6831 @override 7278 @override
6832 R visitStaticGetterDeclaration( 7279 R visitFieldInitializer(
7280 SendSet node,
7281 FieldElement field,
7282 Node initializer,
7283 A arg) {
7284 apply(initializer, arg);
7285 return null;
7286 }
7287
7288 @override
7289 R visitGenerativeConstructorDeclaration(
6833 FunctionExpression node, 7290 FunctionExpression node,
6834 MethodElement getter, 7291 ConstructorElement constructor,
7292 NodeList parameters,
7293 NodeList initializers,
6835 Node body, 7294 Node body,
6836 A arg) { 7295 A arg) {
7296 applyParameters(parameters, arg);
7297 applyInitializers(node, arg);
6837 apply(body, arg); 7298 apply(body, arg);
6838 return null; 7299 return null;
6839 } 7300 }
6840 7301
6841 @override 7302 @override
6842 R visitStaticSetterDeclaration( 7303 R visitInstanceMethodDeclaration(
6843 FunctionExpression node, 7304 FunctionExpression node,
6844 MethodElement setter, 7305 MethodElement method,
6845 NodeList parameters, 7306 NodeList parameters,
6846 Node body, 7307 Node body,
6847 A arg) { 7308 A arg) {
6848 applyParameters(parameters, arg); 7309 applyParameters(parameters, arg);
6849 apply(body, arg); 7310 apply(body, arg);
6850 return null; 7311 return null;
6851 } 7312 }
6852 7313
6853 @override 7314 @override
6854 R visitTopLevelGetterDeclaration( 7315 R visitLocalFunctionDeclaration(
6855 FunctionExpression node, 7316 FunctionExpression node,
6856 MethodElement getter, 7317 LocalFunctionElement function,
6857 Node body,
6858 A arg) {
6859 apply(body, arg);
6860 return null;
6861 }
6862
6863 @override
6864 R visitTopLevelSetterDeclaration(
6865 FunctionExpression node,
6866 MethodElement setter,
6867 NodeList parameters, 7318 NodeList parameters,
6868 Node body, 7319 Node body,
6869 A arg) { 7320 A arg) {
6870 applyParameters(parameters, arg); 7321 applyParameters(parameters, arg);
6871 apply(body, arg); 7322 apply(body, arg);
6872 return null; 7323 return null;
6873 } 7324 }
7325
7326 @override
7327 R visitRedirectingFactoryConstructorDeclaration(
7328 FunctionExpression node,
7329 ConstructorElement constructor,
7330 NodeList parameters,
7331 InterfaceType redirectionType,
7332 ConstructorElement redirectionTarget,
7333 A arg) {
7334 applyParameters(parameters, arg);
7335 return null;
7336 }
7337
7338 @override
7339 R visitRedirectingGenerativeConstructorDeclaration(
7340 FunctionExpression node,
7341 ConstructorElement constructor,
7342 NodeList parameters,
7343 NodeList initializers,
7344 A arg) {
7345 applyParameters(parameters, arg);
7346 applyInitializers(node, arg);
7347 return null;
7348 }
7349
7350 @override
7351 R visitStaticFunctionDeclaration(
7352 FunctionExpression node,
7353 MethodElement function,
7354 NodeList parameters,
7355 Node body,
7356 A arg) {
7357 applyParameters(parameters, arg);
7358 apply(body, arg);
7359 return null;
7360 }
7361
7362 @override
7363 R visitSuperConstructorInvoke(
7364 Send node,
7365 ConstructorElement superConstructor,
7366 InterfaceType type,
7367 NodeList arguments,
7368 CallStructure callStructure,
7369 A arg) {
7370 apply(arguments, arg);
7371 return null;
7372 }
7373
7374 @override
7375 R visitImplicitSuperConstructorInvoke(
7376 FunctionExpression node,
7377 ConstructorElement superConstructor,
7378 InterfaceType type,
7379 A arg) {
7380 return null;
7381 }
7382
7383 @override
7384 R visitThisConstructorInvoke(
7385 Send node,
7386 ConstructorElement thisConstructor,
7387 NodeList arguments,
7388 CallStructure callStructure,
7389 A arg) {
7390 apply(arguments, arg);
7391 return null;
7392 }
7393
7394 @override
7395 R visitTopLevelFunctionDeclaration(
7396 FunctionExpression node,
7397 MethodElement function,
7398 NodeList parameters,
7399 Node body,
7400 A arg) {
7401 applyParameters(parameters, arg);
7402 apply(body, arg);
7403 return null;
7404 }
7405
7406 @override
7407 R errorUnresolvedFieldInitializer(
7408 SendSet node,
7409 Element element,
7410 Node initializer,
7411 A arg) {
7412 apply(initializer, arg);
7413 return null;
7414 }
7415
7416 @override
7417 R errorUnresolvedSuperConstructorInvoke(
7418 Send node,
7419 Element element,
7420 NodeList arguments,
7421 Selector selector,
7422 A arg) {
7423 apply(arguments, arg);
7424 return null;
7425 }
7426
7427 @override
7428 R errorUnresolvedThisConstructorInvoke(
7429 Send node,
7430 Element element,
7431 NodeList arguments,
7432 Selector selector,
7433 A arg) {
7434 apply(arguments, arg);
7435 return null;
7436 }
7437
7438 @override
7439 R visitLocalVariableDeclaration(
7440 VariableDefinitions node,
7441 Node definition,
7442 LocalVariableElement variable,
7443 Node initializer,
7444 A arg) {
7445 if (initializer != null) {
7446 apply(initializer, arg);
7447 }
7448 return null;
7449 }
7450
7451 @override
7452 R visitOptionalParameterDeclaration(
7453 VariableDefinitions node,
7454 Node definition,
7455 ParameterElement parameter,
7456 ConstantExpression defaultValue,
7457 int index,
7458 A arg) {
7459 return null;
7460 }
7461
7462 @override
7463 R visitParameterDeclaration(
7464 VariableDefinitions node,
7465 Node definition,
7466 ParameterElement parameter,
7467 int index,
7468 A arg) {
7469 return null;
7470 }
7471
7472 @override
7473 R visitInitializingFormalDeclaration(
7474 VariableDefinitions node,
7475 Node definition,
7476 InitializingFormalElement initializingFormal,
7477 int index,
7478 A arg) {
7479 return null;
7480 }
7481
7482 @override
7483 R visitLocalConstantDeclaration(
7484 VariableDefinitions node,
7485 Node definition,
7486 LocalVariableElement variable,
7487 ConstantExpression constant,
7488 A arg) {
7489 return null;
7490 }
7491
7492 @override
7493 R visitNamedInitializingFormalDeclaration(
7494 VariableDefinitions node,
7495 Node definition,
7496 InitializingFormalElement initializingFormal,
7497 ConstantExpression defaultValue,
7498 A arg) {
7499 return null;
7500 }
7501
7502 @override
7503 R visitNamedParameterDeclaration(
7504 VariableDefinitions node,
7505 Node definition,
7506 ParameterElement parameter,
7507 ConstantExpression defaultValue,
7508 A arg) {
7509 return null;
7510 }
7511
7512 @override
7513 R visitOptionalInitializingFormalDeclaration(
7514 VariableDefinitions node,
7515 Node definition,
7516 InitializingFormalElement initializingFormal,
7517 ConstantExpression defaultValue,
7518 int index,
7519 A arg) {
7520 return null;
7521 }
7522
7523 @override
7524 R visitInstanceFieldDeclaration(
7525 VariableDefinitions node,
7526 Node definition,
7527 FieldElement field,
7528 Node initializer,
7529 A arg) {
7530 if (initializer != null) {
7531 apply(initializer, arg);
7532 }
7533 return null;
7534 }
7535
7536 @override
7537 R visitStaticConstantDeclaration(
7538 VariableDefinitions node,
7539 Node definition,
7540 FieldElement field,
7541 ConstantExpression constant,
7542 A arg) {
7543 return null;
7544 }
7545
7546 @override
7547 R visitStaticFieldDeclaration(
7548 VariableDefinitions node,
7549 Node definition,
7550 FieldElement field,
7551 Node initializer,
7552 A arg) {
7553 if (initializer != null) {
7554 apply(initializer, arg);
7555 }
7556 return null;
7557 }
7558
7559 @override
7560 R visitTopLevelConstantDeclaration(
7561 VariableDefinitions node,
7562 Node definition,
7563 FieldElement field,
7564 ConstantExpression constant,
7565 A arg) {
7566 return null;
7567 }
7568
7569 @override
7570 R visitTopLevelFieldDeclaration(
7571 VariableDefinitions node,
7572 Node definition,
7573 FieldElement field,
7574 Node initializer,
7575 A arg) {
7576 if (initializer != null) {
7577 apply(initializer, arg);
7578 }
7579 return null;
7580 }
7581
7582 @override
7583 R visitAbstractGetterDeclaration(
7584 FunctionExpression node,
7585 MethodElement getter,
7586 A arg) {
7587 return null;
7588 }
7589
7590 @override
7591 R visitAbstractSetterDeclaration(
7592 FunctionExpression node,
7593 MethodElement setter,
7594 NodeList parameters,
7595 A arg) {
7596 applyParameters(parameters, arg);
7597 return null;
7598 }
7599
7600 @override
7601 R visitInstanceGetterDeclaration(
7602 FunctionExpression node,
7603 MethodElement getter,
7604 Node body,
7605 A arg) {
7606 apply(body, arg);
7607 return null;
7608 }
7609
7610 @override
7611 R visitInstanceSetterDeclaration(
7612 FunctionExpression node,
7613 MethodElement setter,
7614 NodeList parameters,
7615 Node body,
7616 A arg) {
7617 applyParameters(parameters, arg);
7618 apply(body, arg);
7619 return null;
7620 }
7621
7622 @override
7623 R visitStaticGetterDeclaration(
7624 FunctionExpression node,
7625 MethodElement getter,
7626 Node body,
7627 A arg) {
7628 apply(body, arg);
7629 return null;
7630 }
7631
7632 @override
7633 R visitStaticSetterDeclaration(
7634 FunctionExpression node,
7635 MethodElement setter,
7636 NodeList parameters,
7637 Node body,
7638 A arg) {
7639 applyParameters(parameters, arg);
7640 apply(body, arg);
7641 return null;
7642 }
7643
7644 @override
7645 R visitTopLevelGetterDeclaration(
7646 FunctionExpression node,
7647 MethodElement getter,
7648 Node body,
7649 A arg) {
7650 apply(body, arg);
7651 return null;
7652 }
7653
7654 @override
7655 R visitTopLevelSetterDeclaration(
7656 FunctionExpression node,
7657 MethodElement setter,
7658 NodeList parameters,
7659 Node body,
7660 A arg) {
7661 applyParameters(parameters, arg);
7662 apply(body, arg);
7663 return null;
7664 }
6874 } 7665 }
6875 7666
6876 /// AST visitor that visits all normal [Send] and [SendSet] nodes using the 7667 /// AST visitor that visits all normal [Send] and [SendSet] nodes using the
6877 /// [SemanticVisitor]. 7668 /// [SemanticVisitor].
6878 class TraversalVisitor<R, A> extends SemanticVisitor<R, A> 7669 class TraversalVisitor<R, A> extends SemanticVisitor<R, A>
6879 with TraversalSendMixin<R, A>, 7670 with TraversalSendMixin<R, A>,
6880 TraversalDeclarationMixin<R, A> { 7671 TraversalDeclarationMixin<R, A> {
6881 TraversalVisitor(TreeElements elements) : super(elements); 7672 TraversalVisitor(TreeElements elements) : super(elements);
6882 7673
6883 SemanticSendVisitor<R, A> get sendVisitor => this; 7674 SemanticSendVisitor<R, A> get sendVisitor => this;
(...skipping 1963 matching lines...) Expand 10 before | Expand all | Expand 10 after
8847 constant, 9638 constant,
8848 new AssignmentCompound(operator, rhs), 9639 new AssignmentCompound(operator, rhs),
8849 arg); 9640 arg);
8850 } 9641 }
8851 9642
8852 9643
8853 R visitDynamicPropertyPrefix( 9644 R visitDynamicPropertyPrefix(
8854 Send node, 9645 Send node,
8855 Node receiver, 9646 Node receiver,
8856 Name name, 9647 Name name,
9648 IncDecOperator operator,
9649 A arg) {
9650 return handleDynamicCompounds(
9651 node,
9652 receiver,
9653 name,
9654 new IncDecCompound(CompoundKind.PREFIX, operator),
9655 arg);
9656 }
9657
9658 R visitIfNotNullDynamicPropertyPrefix(
9659 Send node,
9660 Node receiver,
9661 Name name,
9662 IncDecOperator operator,
9663 A arg) {
9664 return handleDynamicCompounds(
9665 node,
9666 receiver,
9667 name,
9668 new IncDecCompound(CompoundKind.PREFIX, operator),
9669 arg);
9670 }
9671
9672 @override
9673 R visitParameterPrefix(
9674 Send node,
9675 ParameterElement parameter,
9676 IncDecOperator operator,
9677 A arg) {
9678 return handleLocalCompounds(
9679 node,
9680 parameter,
9681 new IncDecCompound(CompoundKind.PREFIX, operator),
9682 arg,
9683 isSetterValid: true);
9684 }
9685
9686 @override
9687 R visitLocalVariablePrefix(
9688 Send node,
9689 LocalVariableElement variable,
9690 IncDecOperator operator,
9691 A arg) {
9692 return handleLocalCompounds(
9693 node,
9694 variable,
9695 new IncDecCompound(CompoundKind.PREFIX, operator),
9696 arg,
9697 isSetterValid: true);
9698 }
9699
9700 @override
9701 R visitLocalFunctionPrefix(
9702 Send node,
9703 LocalFunctionElement function,
9704 IncDecOperator operator,
9705 A arg) {
9706 return handleLocalCompounds(
9707 node,
9708 function,
9709 new IncDecCompound(CompoundKind.PREFIX, operator),
9710 arg,
9711 isSetterValid: false);
9712 }
9713
9714
9715 R visitThisPropertyPrefix(
9716 Send node,
9717 Name name,
9718 IncDecOperator operator,
9719 A arg) {
9720 return handleDynamicCompounds(
9721 node,
9722 null,
9723 name,
9724 new IncDecCompound(CompoundKind.PREFIX, operator),
9725 arg);
9726 }
9727
9728 @override
9729 R visitStaticFieldPrefix(
9730 Send node,
9731 FieldElement field,
9732 IncDecOperator operator,
9733 A arg) {
9734 return handleStaticCompounds(
9735 node,
9736 field, CompoundGetter.FIELD,
9737 field, CompoundSetter.FIELD,
9738 new IncDecCompound(CompoundKind.PREFIX, operator),
9739 arg);
9740 }
9741
9742 @override
9743 R visitStaticGetterSetterPrefix(
9744 Send node,
9745 FunctionElement getter,
9746 FunctionElement setter,
9747 IncDecOperator operator,
9748 A arg) {
9749 return handleStaticCompounds(
9750 node,
9751 getter, CompoundGetter.GETTER,
9752 setter, CompoundSetter.SETTER,
9753 new IncDecCompound(CompoundKind.PREFIX, operator),
9754 arg);
9755 }
9756
9757
9758 R visitStaticMethodSetterPrefix(
9759 Send node,
9760 FunctionElement getter,
9761 FunctionElement setter,
9762 IncDecOperator operator,
9763 A arg) {
9764 return handleStaticCompounds(
9765 node,
9766 getter, CompoundGetter.METHOD,
9767 setter, CompoundSetter.SETTER,
9768 new IncDecCompound(CompoundKind.PREFIX, operator),
9769 arg);
9770 }
9771
9772 @override
9773 R visitTopLevelFieldPrefix(
9774 Send node,
9775 FieldElement field,
9776 IncDecOperator operator,
9777 A arg) {
9778 return handleStaticCompounds(
9779 node,
9780 field, CompoundGetter.FIELD,
9781 field, CompoundSetter.FIELD,
9782 new IncDecCompound(CompoundKind.PREFIX, operator),
9783 arg);
9784 }
9785
9786 @override
9787 R visitTopLevelGetterSetterPrefix(
9788 Send node,
9789 FunctionElement getter,
9790 FunctionElement setter,
9791 IncDecOperator operator,
9792 A arg) {
9793 return handleStaticCompounds(
9794 node,
9795 getter, CompoundGetter.GETTER,
9796 setter, CompoundSetter.SETTER,
9797 new IncDecCompound(CompoundKind.PREFIX, operator),
9798 arg);
9799 }
9800
9801 @override
9802 R visitTopLevelMethodSetterPrefix(
9803 Send node,
9804 FunctionElement method,
9805 FunctionElement setter,
9806 IncDecOperator operator,
9807 A arg) {
9808 return handleStaticCompounds(
9809 node,
9810 method, CompoundGetter.METHOD,
9811 setter, CompoundSetter.SETTER,
9812 new IncDecCompound(CompoundKind.PREFIX, operator),
9813 arg);
9814 }
9815
9816 @override
9817 R visitSuperFieldPrefix(
9818 Send node,
9819 FieldElement field,
9820 IncDecOperator operator,
9821 A arg) {
9822 return handleSuperCompounds(
9823 node,
9824 field, CompoundGetter.FIELD,
9825 field, CompoundSetter.FIELD,
9826 new IncDecCompound(CompoundKind.PREFIX, operator),
9827 arg);
9828 }
9829
9830 @override
9831 R visitSuperFieldFieldPrefix(
9832 Send node,
9833 FieldElement readField,
9834 FieldElement writtenField,
9835 IncDecOperator operator,
9836 A arg) {
9837 return handleSuperCompounds(
9838 node,
9839 readField, CompoundGetter.FIELD,
9840 writtenField, CompoundSetter.FIELD,
9841 new IncDecCompound(CompoundKind.PREFIX, operator),
9842 arg);
9843 }
9844
9845 @override
9846 R visitSuperFieldSetterPrefix(
9847 Send node,
9848 FieldElement field,
9849 FunctionElement setter,
9850 IncDecOperator operator,
9851 A arg) {
9852 return handleSuperCompounds(
9853 node,
9854 field, CompoundGetter.FIELD,
9855 setter, CompoundSetter.SETTER,
9856 new IncDecCompound(CompoundKind.PREFIX, operator),
9857 arg);
9858 }
9859
9860
9861 R visitSuperGetterSetterPrefix(
9862 Send node,
9863 FunctionElement getter,
9864 FunctionElement setter,
9865 IncDecOperator operator,
9866 A arg) {
9867 return handleSuperCompounds(
9868 node,
9869 getter, CompoundGetter.GETTER,
9870 setter, CompoundSetter.SETTER,
9871 new IncDecCompound(CompoundKind.PREFIX, operator),
9872 arg);
9873 }
9874
9875 @override
9876 R visitSuperGetterFieldPrefix(
9877 Send node,
9878 FunctionElement getter,
9879 FieldElement field,
9880 IncDecOperator operator,
9881 A arg) {
9882 return handleSuperCompounds(
9883 node,
9884 getter, CompoundGetter.GETTER,
9885 field, CompoundSetter.FIELD,
9886 new IncDecCompound(CompoundKind.PREFIX, operator),
9887 arg);
9888 }
9889
9890 @override
9891 R visitSuperMethodSetterPrefix(
9892 Send node,
9893 FunctionElement method,
9894 FunctionElement setter,
9895 IncDecOperator operator,
9896 A arg) {
9897 return handleSuperCompounds(
9898 node,
9899 method, CompoundGetter.METHOD,
9900 setter, CompoundSetter.SETTER,
9901 new IncDecCompound(CompoundKind.PREFIX, operator),
9902 arg);
9903 }
9904
9905 @override
9906 R visitClassTypeLiteralPrefix(
9907 Send node,
9908 ConstantExpression constant,
9909 IncDecOperator operator,
9910 A arg) {
9911 return handleTypeLiteralConstantCompounds(
9912 node,
9913 constant,
9914 new IncDecCompound(CompoundKind.PREFIX, operator),
9915 arg);
9916 }
9917
9918 @override
9919 R visitTypedefTypeLiteralPrefix(
9920 Send node,
9921 ConstantExpression constant,
9922 IncDecOperator operator,
9923 A arg) {
9924 return handleTypeLiteralConstantCompounds(
9925 node,
9926 constant,
9927 new IncDecCompound(CompoundKind.PREFIX, operator),
9928 arg);
9929 }
9930
9931 @override
9932 R visitTypeVariableTypeLiteralPrefix(
9933 Send node,
9934 TypeVariableElement element,
9935 IncDecOperator operator,
9936 A arg) {
9937 return handleTypeVariableTypeLiteralCompounds(
9938 node,
9939 element,
9940 new IncDecCompound(CompoundKind.PREFIX, operator),
9941 arg);
9942 }
9943
9944 @override
9945 R visitDynamicTypeLiteralPrefix(
9946 Send node,
9947 ConstantExpression constant,
9948 IncDecOperator operator,
9949 A arg) {
9950 return handleTypeLiteralConstantCompounds(
9951 node,
9952 constant,
9953 new IncDecCompound(CompoundKind.PREFIX, operator),
9954 arg);
9955 }
9956
9957 @override
9958 R visitDynamicPropertyPostfix(
9959 Send node,
9960 Node receiver,
9961 Name name,
8857 IncDecOperator operator, 9962 IncDecOperator operator,
8858 A arg) { 9963 A arg) {
8859 return handleDynamicCompounds( 9964 return handleDynamicCompounds(
8860 node, 9965 node,
8861 receiver, 9966 receiver,
8862 name, 9967 name,
8863 new IncDecCompound(CompoundKind.PREFIX, operator), 9968 new IncDecCompound(CompoundKind.POSTFIX, operator),
8864 arg); 9969 arg);
8865 } 9970 }
8866 9971
8867 R visitIfNotNullDynamicPropertyPrefix( 9972 @override
9973 R visitIfNotNullDynamicPropertyPostfix(
8868 Send node, 9974 Send node,
8869 Node receiver, 9975 Node receiver,
8870 Name name, 9976 Name name,
8871 IncDecOperator operator, 9977 IncDecOperator operator,
8872 A arg) { 9978 A arg) {
8873 return handleDynamicCompounds( 9979 return handleDynamicCompounds(
8874 node, 9980 node,
8875 receiver, 9981 receiver,
8876 name, 9982 name,
8877 new IncDecCompound(CompoundKind.PREFIX, operator), 9983 new IncDecCompound(CompoundKind.POSTFIX, operator),
8878 arg); 9984 arg);
8879 } 9985 }
8880 9986
8881 @override 9987 @override
8882 R visitParameterPrefix( 9988 R visitParameterPostfix(
8883 Send node, 9989 Send node,
8884 ParameterElement parameter, 9990 ParameterElement parameter,
8885 IncDecOperator operator, 9991 IncDecOperator operator,
8886 A arg) { 9992 A arg) {
8887 return handleLocalCompounds( 9993 return handleLocalCompounds(
8888 node, 9994 node,
8889 parameter, 9995 parameter,
8890 new IncDecCompound(CompoundKind.PREFIX, operator), 9996 new IncDecCompound(CompoundKind.POSTFIX, operator),
8891 arg, 9997 arg,
8892 isSetterValid: true); 9998 isSetterValid: true);
8893 } 9999 }
8894 10000
8895 @override 10001 @override
8896 R visitLocalVariablePrefix( 10002 R visitLocalVariablePostfix(
8897 Send node, 10003 Send node,
8898 LocalVariableElement variable, 10004 LocalVariableElement variable,
8899 IncDecOperator operator, 10005 IncDecOperator operator,
8900 A arg) { 10006 A arg) {
8901 return handleLocalCompounds( 10007 return handleLocalCompounds(
8902 node, 10008 node,
8903 variable, 10009 variable,
8904 new IncDecCompound(CompoundKind.PREFIX, operator), 10010 new IncDecCompound(CompoundKind.POSTFIX, operator),
8905 arg, 10011 arg,
8906 isSetterValid: true); 10012 isSetterValid: true);
8907 } 10013 }
8908 10014
8909 @override 10015 @override
8910 R visitLocalFunctionPrefix( 10016 R visitLocalFunctionPostfix(
8911 Send node, 10017 Send node,
8912 LocalFunctionElement function, 10018 LocalFunctionElement function,
8913 IncDecOperator operator, 10019 IncDecOperator operator,
8914 A arg) { 10020 A arg) {
8915 return handleLocalCompounds( 10021 return handleLocalCompounds(
8916 node, 10022 node,
8917 function, 10023 function,
8918 new IncDecCompound(CompoundKind.PREFIX, operator), 10024 new IncDecCompound(CompoundKind.POSTFIX, operator),
8919 arg, 10025 arg,
8920 isSetterValid: false); 10026 isSetterValid: false);
8921 } 10027 }
8922 10028
8923 10029
8924 R visitThisPropertyPrefix( 10030 R visitThisPropertyPostfix(
8925 Send node, 10031 Send node,
8926 Name name, 10032 Name name,
8927 IncDecOperator operator, 10033 IncDecOperator operator,
8928 A arg) { 10034 A arg) {
8929 return handleDynamicCompounds( 10035 return handleDynamicCompounds(
8930 node, 10036 node,
8931 null, 10037 null,
8932 name, 10038 name,
8933 new IncDecCompound(CompoundKind.PREFIX, operator), 10039 new IncDecCompound(CompoundKind.POSTFIX, operator),
8934 arg); 10040 arg);
8935 } 10041 }
8936 10042
8937 @override 10043 @override
8938 R visitStaticFieldPrefix( 10044 R visitStaticFieldPostfix(
8939 Send node, 10045 Send node,
8940 FieldElement field, 10046 FieldElement field,
8941 IncDecOperator operator, 10047 IncDecOperator operator,
8942 A arg) { 10048 A arg) {
8943 return handleStaticCompounds( 10049 return handleStaticCompounds(
8944 node, 10050 node,
8945 field, CompoundGetter.FIELD, 10051 field, CompoundGetter.FIELD,
8946 field, CompoundSetter.FIELD, 10052 field, CompoundSetter.FIELD,
8947 new IncDecCompound(CompoundKind.PREFIX, operator), 10053 new IncDecCompound(CompoundKind.POSTFIX, operator),
8948 arg); 10054 arg);
8949 } 10055 }
8950 10056
8951 @override 10057 @override
8952 R visitStaticGetterSetterPrefix( 10058 R visitStaticGetterSetterPostfix(
8953 Send node, 10059 Send node,
8954 FunctionElement getter, 10060 FunctionElement getter,
8955 FunctionElement setter, 10061 FunctionElement setter,
8956 IncDecOperator operator, 10062 IncDecOperator operator,
8957 A arg) { 10063 A arg) {
8958 return handleStaticCompounds( 10064 return handleStaticCompounds(
8959 node, 10065 node,
8960 getter, CompoundGetter.GETTER, 10066 getter, CompoundGetter.GETTER,
8961 setter, CompoundSetter.SETTER, 10067 setter, CompoundSetter.SETTER,
8962 new IncDecCompound(CompoundKind.PREFIX, operator), 10068 new IncDecCompound(CompoundKind.POSTFIX, operator),
8963 arg); 10069 arg);
8964 } 10070 }
8965 10071
8966 10072
8967 R visitStaticMethodSetterPrefix( 10073 R visitStaticMethodSetterPostfix(
8968 Send node, 10074 Send node,
8969 FunctionElement getter, 10075 FunctionElement getter,
8970 FunctionElement setter, 10076 FunctionElement setter,
8971 IncDecOperator operator, 10077 IncDecOperator operator,
8972 A arg) { 10078 A arg) {
8973 return handleStaticCompounds( 10079 return handleStaticCompounds(
8974 node, 10080 node,
8975 getter, CompoundGetter.METHOD, 10081 getter, CompoundGetter.METHOD,
8976 setter, CompoundSetter.SETTER, 10082 setter, CompoundSetter.SETTER,
8977 new IncDecCompound(CompoundKind.PREFIX, operator), 10083 new IncDecCompound(CompoundKind.POSTFIX, operator),
8978 arg); 10084 arg);
8979 } 10085 }
8980 10086
8981 @override 10087 @override
8982 R visitTopLevelFieldPrefix( 10088 R visitTopLevelFieldPostfix(
8983 Send node, 10089 Send node,
8984 FieldElement field, 10090 FieldElement field,
8985 IncDecOperator operator, 10091 IncDecOperator operator,
8986 A arg) { 10092 A arg) {
8987 return handleStaticCompounds( 10093 return handleStaticCompounds(
8988 node, 10094 node,
8989 field, CompoundGetter.FIELD, 10095 field, CompoundGetter.FIELD,
8990 field, CompoundSetter.FIELD, 10096 field, CompoundSetter.FIELD,
8991 new IncDecCompound(CompoundKind.PREFIX, operator), 10097 new IncDecCompound(CompoundKind.POSTFIX, operator),
8992 arg); 10098 arg);
8993 } 10099 }
8994 10100
8995 @override 10101 @override
8996 R visitTopLevelGetterSetterPrefix( 10102 R visitTopLevelGetterSetterPostfix(
8997 Send node, 10103 Send node,
8998 FunctionElement getter, 10104 FunctionElement getter,
8999 FunctionElement setter, 10105 FunctionElement setter,
9000 IncDecOperator operator, 10106 IncDecOperator operator,
9001 A arg) { 10107 A arg) {
9002 return handleStaticCompounds( 10108 return handleStaticCompounds(
9003 node, 10109 node,
9004 getter, CompoundGetter.GETTER, 10110 getter, CompoundGetter.GETTER,
9005 setter, CompoundSetter.SETTER, 10111 setter, CompoundSetter.SETTER,
9006 new IncDecCompound(CompoundKind.PREFIX, operator), 10112 new IncDecCompound(CompoundKind.POSTFIX, operator),
9007 arg); 10113 arg);
9008 } 10114 }
9009 10115
9010 @override 10116 @override
9011 R visitTopLevelMethodSetterPrefix( 10117 R visitTopLevelMethodSetterPostfix(
9012 Send node, 10118 Send node,
9013 FunctionElement method, 10119 FunctionElement method,
9014 FunctionElement setter, 10120 FunctionElement setter,
9015 IncDecOperator operator, 10121 IncDecOperator operator,
9016 A arg) { 10122 A arg) {
9017 return handleStaticCompounds( 10123 return handleStaticCompounds(
9018 node, 10124 node,
9019 method, CompoundGetter.METHOD, 10125 method, CompoundGetter.METHOD,
9020 setter, CompoundSetter.SETTER, 10126 setter, CompoundSetter.SETTER,
9021 new IncDecCompound(CompoundKind.PREFIX, operator), 10127 new IncDecCompound(CompoundKind.POSTFIX, operator),
9022 arg); 10128 arg);
9023 } 10129 }
9024 10130
9025 @override 10131 @override
9026 R visitSuperFieldPrefix( 10132 R visitSuperFieldPostfix(
9027 Send node, 10133 Send node,
9028 FieldElement field, 10134 FieldElement field,
9029 IncDecOperator operator, 10135 IncDecOperator operator,
9030 A arg) { 10136 A arg) {
9031 return handleSuperCompounds( 10137 return handleSuperCompounds(
9032 node, 10138 node,
9033 field, CompoundGetter.FIELD, 10139 field, CompoundGetter.FIELD,
9034 field, CompoundSetter.FIELD, 10140 field, CompoundSetter.FIELD,
9035 new IncDecCompound(CompoundKind.PREFIX, operator), 10141 new IncDecCompound(CompoundKind.POSTFIX, operator),
9036 arg); 10142 arg);
9037 } 10143 }
9038 10144
9039 @override 10145 @override
9040 R visitSuperFieldFieldPrefix( 10146 R visitSuperFieldFieldPostfix(
9041 Send node, 10147 Send node,
9042 FieldElement readField, 10148 FieldElement readField,
9043 FieldElement writtenField, 10149 FieldElement writtenField,
9044 IncDecOperator operator, 10150 IncDecOperator operator,
9045 A arg) { 10151 A arg) {
9046 return handleSuperCompounds( 10152 return handleSuperCompounds(
9047 node, 10153 node,
9048 readField, CompoundGetter.FIELD, 10154 readField, CompoundGetter.FIELD,
9049 writtenField, CompoundSetter.FIELD, 10155 writtenField, CompoundSetter.FIELD,
9050 new IncDecCompound(CompoundKind.PREFIX, operator), 10156 new IncDecCompound(CompoundKind.POSTFIX, operator),
9051 arg); 10157 arg);
9052 } 10158 }
9053 10159
9054 @override 10160 @override
9055 R visitSuperFieldSetterPrefix( 10161 R visitSuperFieldSetterPostfix(
9056 Send node, 10162 Send node,
9057 FieldElement field, 10163 FieldElement field,
9058 FunctionElement setter, 10164 FunctionElement setter,
9059 IncDecOperator operator, 10165 IncDecOperator operator,
9060 A arg) { 10166 A arg) {
9061 return handleSuperCompounds( 10167 return handleSuperCompounds(
9062 node, 10168 node,
9063 field, CompoundGetter.FIELD, 10169 field, CompoundGetter.FIELD,
9064 setter, CompoundSetter.SETTER, 10170 setter, CompoundSetter.SETTER,
9065 new IncDecCompound(CompoundKind.PREFIX, operator), 10171 new IncDecCompound(CompoundKind.POSTFIX, operator),
9066 arg); 10172 arg);
9067 } 10173 }
9068 10174
9069 10175
9070 R visitSuperGetterSetterPrefix( 10176 R visitSuperGetterSetterPostfix(
9071 Send node, 10177 Send node,
9072 FunctionElement getter, 10178 FunctionElement getter,
9073 FunctionElement setter, 10179 FunctionElement setter,
9074 IncDecOperator operator, 10180 IncDecOperator operator,
9075 A arg) { 10181 A arg) {
9076 return handleSuperCompounds( 10182 return handleSuperCompounds(
9077 node, 10183 node,
9078 getter, CompoundGetter.GETTER, 10184 getter, CompoundGetter.GETTER,
9079 setter, CompoundSetter.SETTER, 10185 setter, CompoundSetter.SETTER,
9080 new IncDecCompound(CompoundKind.PREFIX, operator), 10186 new IncDecCompound(CompoundKind.POSTFIX, operator),
9081 arg); 10187 arg);
9082 } 10188 }
9083 10189
9084 @override 10190 @override
9085 R visitSuperGetterFieldPrefix( 10191 R visitSuperGetterFieldPostfix(
9086 Send node, 10192 Send node,
9087 FunctionElement getter, 10193 FunctionElement getter,
9088 FieldElement field, 10194 FieldElement field,
9089 IncDecOperator operator, 10195 IncDecOperator operator,
9090 A arg) { 10196 A arg) {
9091 return handleSuperCompounds( 10197 return handleSuperCompounds(
9092 node, 10198 node,
9093 getter, CompoundGetter.GETTER, 10199 getter, CompoundGetter.GETTER,
9094 field, CompoundSetter.FIELD, 10200 field, CompoundSetter.FIELD,
9095 new IncDecCompound(CompoundKind.PREFIX, operator), 10201 new IncDecCompound(CompoundKind.POSTFIX, operator),
9096 arg); 10202 arg);
9097 } 10203 }
9098 10204
9099 @override 10205 @override
9100 R visitSuperMethodSetterPrefix( 10206 R visitSuperMethodSetterPostfix(
9101 Send node, 10207 Send node,
9102 FunctionElement method, 10208 FunctionElement method,
9103 FunctionElement setter, 10209 FunctionElement setter,
9104 IncDecOperator operator, 10210 IncDecOperator operator,
9105 A arg) { 10211 A arg) {
9106 return handleSuperCompounds( 10212 return handleSuperCompounds(
9107 node, 10213 node,
9108 method, CompoundGetter.METHOD, 10214 method, CompoundGetter.METHOD,
9109 setter, CompoundSetter.SETTER, 10215 setter, CompoundSetter.SETTER,
9110 new IncDecCompound(CompoundKind.PREFIX, operator), 10216 new IncDecCompound(CompoundKind.POSTFIX, operator),
9111 arg); 10217 arg);
9112 } 10218 }
9113 10219
9114 @override 10220 @override
9115 R visitClassTypeLiteralPrefix( 10221 R visitClassTypeLiteralPostfix(
9116 Send node, 10222 Send node,
9117 ConstantExpression constant, 10223 ConstantExpression constant,
9118 IncDecOperator operator, 10224 IncDecOperator operator,
9119 A arg) { 10225 A arg) {
9120 return handleTypeLiteralConstantCompounds( 10226 return handleTypeLiteralConstantCompounds(
9121 node, 10227 node,
9122 constant, 10228 constant,
9123 new IncDecCompound(CompoundKind.PREFIX, operator), 10229 new IncDecCompound(CompoundKind.POSTFIX, operator),
9124 arg); 10230 arg);
9125 } 10231 }
9126 10232
9127 @override 10233 @override
9128 R visitTypedefTypeLiteralPrefix( 10234 R visitTypedefTypeLiteralPostfix(
9129 Send node, 10235 Send node,
9130 ConstantExpression constant, 10236 ConstantExpression constant,
9131 IncDecOperator operator, 10237 IncDecOperator operator,
9132 A arg) { 10238 A arg) {
9133 return handleTypeLiteralConstantCompounds( 10239 return handleTypeLiteralConstantCompounds(
9134 node, 10240 node,
9135 constant, 10241 constant,
9136 new IncDecCompound(CompoundKind.PREFIX, operator), 10242 new IncDecCompound(CompoundKind.POSTFIX, operator),
9137 arg); 10243 arg);
9138 } 10244 }
9139 10245
9140 @override 10246 @override
9141 R visitTypeVariableTypeLiteralPrefix( 10247 R visitTypeVariableTypeLiteralPostfix(
9142 Send node, 10248 Send node,
9143 TypeVariableElement element, 10249 TypeVariableElement element,
9144 IncDecOperator operator, 10250 IncDecOperator operator,
9145 A arg) { 10251 A arg) {
9146 return handleTypeVariableTypeLiteralCompounds( 10252 return handleTypeVariableTypeLiteralCompounds(
9147 node, 10253 node,
9148 element, 10254 element,
9149 new IncDecCompound(CompoundKind.PREFIX, operator), 10255 new IncDecCompound(CompoundKind.POSTFIX, operator),
9150 arg); 10256 arg);
9151 } 10257 }
9152 10258
9153 @override 10259 @override
9154 R visitDynamicTypeLiteralPrefix( 10260 R visitDynamicTypeLiteralPostfix(
9155 Send node, 10261 Send node,
9156 ConstantExpression constant, 10262 ConstantExpression constant,
9157 IncDecOperator operator, 10263 IncDecOperator operator,
9158 A arg) { 10264 A arg) {
9159 return handleTypeLiteralConstantCompounds( 10265 return handleTypeLiteralConstantCompounds(
9160 node, 10266 node,
9161 constant, 10267 constant,
9162 new IncDecCompound(CompoundKind.PREFIX, operator), 10268 new IncDecCompound(CompoundKind.POSTFIX, operator),
9163 arg); 10269 arg);
9164 } 10270 }
9165 10271
9166 @override 10272 @override
9167 R visitDynamicPropertyPostfix( 10273 R visitUnresolvedStaticGetterPostfix(
9168 Send node, 10274 Send node,
9169 Node receiver, 10275 Element element,
9170 Name name, 10276 MethodElement setter,
9171 IncDecOperator operator, 10277 IncDecOperator operator,
9172 A arg) { 10278 A arg) {
9173 return handleDynamicCompounds( 10279 return handleStaticCompounds(
9174 node, 10280 node,
9175 receiver, 10281 element,
9176 name, 10282 CompoundGetter.UNRESOLVED,
9177 new IncDecCompound(CompoundKind.POSTFIX, operator), 10283 setter,
9178 arg); 10284 CompoundSetter.SETTER,
9179 } 10285 new IncDecCompound(CompoundKind.POSTFIX, operator),
9180 10286 arg);
9181 @override 10287 }
9182 R visitIfNotNullDynamicPropertyPostfix( 10288
9183 Send node, 10289 @override
9184 Node receiver, 10290 R visitUnresolvedTopLevelGetterPostfix(
9185 Name name, 10291 Send node,
9186 IncDecOperator operator, 10292 Element element,
9187 A arg) { 10293 MethodElement setter,
9188 return handleDynamicCompounds( 10294 IncDecOperator operator,
9189 node, 10295 A arg) {
9190 receiver, 10296 return handleStaticCompounds(
9191 name, 10297 node,
9192 new IncDecCompound(CompoundKind.POSTFIX, operator), 10298 element,
9193 arg); 10299 CompoundGetter.UNRESOLVED,
9194 } 10300 setter,
9195 10301 CompoundSetter.SETTER,
9196 @override 10302 new IncDecCompound(CompoundKind.POSTFIX, operator),
9197 R visitParameterPostfix( 10303 arg);
9198 Send node, 10304 }
9199 ParameterElement parameter, 10305
10306 @override
10307 R visitUnresolvedStaticSetterPostfix(
10308 Send node,
10309 MethodElement getter,
10310 Element element,
10311 IncDecOperator operator,
10312 A arg) {
10313 return handleStaticCompounds(
10314 node,
10315 getter,
10316 CompoundGetter.GETTER,
10317 element,
10318 CompoundSetter.INVALID,
10319 new IncDecCompound(CompoundKind.POSTFIX, operator),
10320 arg);
10321 }
10322
10323 @override
10324 R visitUnresolvedTopLevelSetterPostfix(
10325 Send node,
10326 MethodElement getter,
10327 Element element,
10328 IncDecOperator operator,
10329 A arg) {
10330 return handleStaticCompounds(
10331 node,
10332 getter,
10333 CompoundGetter.GETTER,
10334 element,
10335 CompoundSetter.INVALID,
10336 new IncDecCompound(CompoundKind.POSTFIX, operator),
10337 arg);
10338 }
10339
10340 @override
10341 R visitStaticMethodPostfix(
10342 Send node,
10343 MethodElement method,
10344 IncDecOperator operator,
10345 A arg) {
10346 return handleStaticCompounds(
10347 node,
10348 method,
10349 CompoundGetter.METHOD,
10350 method,
10351 CompoundSetter.INVALID,
10352 new IncDecCompound(CompoundKind.POSTFIX, operator),
10353 arg);
10354 }
10355
10356 @override
10357 R visitTopLevelMethodPostfix(
10358 Send node,
10359 MethodElement method,
10360 IncDecOperator operator,
10361 A arg) {
10362 return handleStaticCompounds(
10363 node,
10364 method,
10365 CompoundGetter.METHOD,
10366 method,
10367 CompoundSetter.INVALID,
10368 new IncDecCompound(CompoundKind.POSTFIX, operator),
10369 arg);
10370 }
10371
10372 @override
10373 R visitUnresolvedPostfix(
10374 Send node,
10375 Element element,
10376 IncDecOperator operator,
10377 A arg) {
10378 return handleStaticCompounds(
10379 node,
10380 element,
10381 CompoundGetter.UNRESOLVED,
10382 element,
10383 CompoundSetter.INVALID,
10384 new IncDecCompound(CompoundKind.POSTFIX, operator),
10385 arg);
10386 }
10387
10388 @override
10389 R visitUnresolvedStaticGetterPrefix(
10390 Send node,
10391 Element element,
10392 MethodElement setter,
10393 IncDecOperator operator,
10394 A arg) {
10395 return handleStaticCompounds(
10396 node,
10397 element,
10398 CompoundGetter.UNRESOLVED,
10399 setter,
10400 CompoundSetter.SETTER,
10401 new IncDecCompound(CompoundKind.PREFIX, operator),
10402 arg);
10403 }
10404
10405 @override
10406 R visitUnresolvedTopLevelGetterPrefix(
10407 Send node,
10408 Element element,
10409 MethodElement setter,
10410 IncDecOperator operator,
10411 A arg) {
10412 return handleStaticCompounds(
10413 node,
10414 element,
10415 CompoundGetter.UNRESOLVED,
10416 setter,
10417 CompoundSetter.SETTER,
10418 new IncDecCompound(CompoundKind.PREFIX, operator),
10419 arg);
10420 }
10421
10422 @override
10423 R visitUnresolvedStaticSetterPrefix(
10424 Send node,
10425 MethodElement getter,
10426 Element element,
10427 IncDecOperator operator,
10428 A arg) {
10429 return handleStaticCompounds(
10430 node,
10431 getter,
10432 CompoundGetter.GETTER,
10433 element,
10434 CompoundSetter.INVALID,
10435 new IncDecCompound(CompoundKind.PREFIX, operator),
10436 arg);
10437 }
10438
10439 @override
10440 R visitUnresolvedTopLevelSetterPrefix(
10441 Send node,
10442 MethodElement getter,
10443 Element element,
10444 IncDecOperator operator,
10445 A arg) {
10446 return handleStaticCompounds(
10447 node,
10448 getter,
10449 CompoundGetter.GETTER,
10450 element,
10451 CompoundSetter.INVALID,
10452 new IncDecCompound(CompoundKind.PREFIX, operator),
10453 arg);
10454 }
10455
10456 @override
10457 R visitStaticMethodPrefix(
10458 Send node,
10459 MethodElement method,
10460 IncDecOperator operator,
10461 A arg) {
10462 return handleStaticCompounds(
10463 node,
10464 method,
10465 CompoundGetter.METHOD,
10466 method,
10467 CompoundSetter.INVALID,
10468 new IncDecCompound(CompoundKind.PREFIX, operator),
10469 arg);
10470 }
10471
10472 @override
10473 R visitTopLevelMethodPrefix(
10474 Send node,
10475 MethodElement method,
10476 IncDecOperator operator,
10477 A arg) {
10478 return handleStaticCompounds(
10479 node,
10480 method,
10481 CompoundGetter.METHOD,
10482 method,
10483 CompoundSetter.INVALID,
10484 new IncDecCompound(CompoundKind.PREFIX, operator),
10485 arg);
10486 }
10487
10488 @override
10489 R visitUnresolvedPrefix(
10490 Send node,
10491 Element element,
10492 IncDecOperator operator,
10493 A arg) {
10494 return handleStaticCompounds(
10495 node,
10496 element,
10497 CompoundGetter.UNRESOLVED,
10498 element,
10499 CompoundSetter.INVALID,
10500 new IncDecCompound(CompoundKind.PREFIX, operator),
10501 arg);
10502 }
10503
10504 @override
10505 R visitUnresolvedStaticGetterCompound(
10506 Send node,
10507 Element element,
10508 MethodElement setter,
10509 AssignmentOperator operator,
10510 Node rhs,
10511 A arg) {
10512 return handleStaticCompounds(
10513 node,
10514 element,
10515 CompoundGetter.UNRESOLVED,
10516 setter,
10517 CompoundSetter.SETTER,
10518 new AssignmentCompound(operator, rhs),
10519 arg);
10520 }
10521
10522 @override
10523 R visitUnresolvedTopLevelGetterCompound(
10524 Send node,
10525 Element element,
10526 MethodElement setter,
10527 AssignmentOperator operator,
10528 Node rhs,
10529 A arg) {
10530 return handleStaticCompounds(
10531 node,
10532 element,
10533 CompoundGetter.UNRESOLVED,
10534 setter,
10535 CompoundSetter.SETTER,
10536 new AssignmentCompound(operator, rhs),
10537 arg);
10538 }
10539
10540 @override
10541 R visitUnresolvedStaticSetterCompound(
10542 Send node,
10543 MethodElement getter,
10544 Element element,
10545 AssignmentOperator operator,
10546 Node rhs,
10547 A arg) {
10548 return handleStaticCompounds(
10549 node,
10550 getter,
10551 CompoundGetter.GETTER,
10552 element,
10553 CompoundSetter.INVALID,
10554 new AssignmentCompound(operator, rhs),
10555 arg);
10556 }
10557
10558 @override
10559 R visitUnresolvedTopLevelSetterCompound(
10560 Send node,
10561 MethodElement getter,
10562 Element element,
10563 AssignmentOperator operator,
10564 Node rhs,
10565 A arg) {
10566 return handleStaticCompounds(
10567 node,
10568 getter,
10569 CompoundGetter.GETTER,
10570 element,
10571 CompoundSetter.INVALID,
10572 new AssignmentCompound(operator, rhs),
10573 arg);
10574 }
10575
10576 @override
10577 R visitStaticMethodCompound(
10578 Send node,
10579 MethodElement method,
10580 AssignmentOperator operator,
10581 Node rhs,
10582 A arg) {
10583 return handleStaticCompounds(
10584 node,
10585 method,
10586 CompoundGetter.METHOD,
10587 method,
10588 CompoundSetter.INVALID,
10589 new AssignmentCompound(operator, rhs),
10590 arg);
10591 }
10592
10593 @override
10594 R visitTopLevelMethodCompound(
10595 Send node,
10596 MethodElement method,
10597 AssignmentOperator operator,
10598 Node rhs,
10599 A arg) {
10600 return handleStaticCompounds(
10601 node,
10602 method,
10603 CompoundGetter.METHOD,
10604 method,
10605 CompoundSetter.INVALID,
10606 new AssignmentCompound(operator, rhs),
10607 arg);
10608 }
10609
10610 @override
10611 R visitUnresolvedCompound(
10612 Send node,
10613 Element element,
10614 AssignmentOperator operator,
10615 Node rhs,
10616 A arg) {
10617 return handleStaticCompounds(
10618 node,
10619 element,
10620 CompoundGetter.UNRESOLVED,
10621 element,
10622 CompoundSetter.INVALID,
10623 new AssignmentCompound(operator, rhs),
10624 arg);
10625 }
10626
10627 @override
10628 R visitFinalLocalVariablePostfix(
10629 Send node,
10630 LocalVariableElement variable,
9200 IncDecOperator operator, 10631 IncDecOperator operator,
9201 A arg) { 10632 A arg) {
9202 return handleLocalCompounds( 10633 return handleLocalCompounds(
9203 node, 10634 node,
9204 parameter,
9205 new IncDecCompound(CompoundKind.POSTFIX, operator),
9206 arg,
9207 isSetterValid: true);
9208 }
9209
9210 @override
9211 R visitLocalVariablePostfix(
9212 Send node,
9213 LocalVariableElement variable,
9214 IncDecOperator operator,
9215 A arg) {
9216 return handleLocalCompounds(
9217 node,
9218 variable, 10635 variable,
9219 new IncDecCompound(CompoundKind.POSTFIX, operator), 10636 new IncDecCompound(CompoundKind.POSTFIX, operator),
9220 arg, 10637 arg,
9221 isSetterValid: true);
9222 }
9223
9224 @override
9225 R visitLocalFunctionPostfix(
9226 Send node,
9227 LocalFunctionElement function,
9228 IncDecOperator operator,
9229 A arg) {
9230 return handleLocalCompounds(
9231 node,
9232 function,
9233 new IncDecCompound(CompoundKind.POSTFIX, operator),
9234 arg,
9235 isSetterValid: false); 10638 isSetterValid: false);
9236 } 10639 }
9237 10640
9238 10641 @override
9239 R visitThisPropertyPostfix( 10642 R visitFinalLocalVariablePrefix(
9240 Send node, 10643 Send node,
9241 Name name, 10644 LocalVariableElement variable,
9242 IncDecOperator operator, 10645 IncDecOperator operator,
9243 A arg) { 10646 A arg) {
9244 return handleDynamicCompounds( 10647 return handleLocalCompounds(
9245 node, 10648 node,
9246 null, 10649 variable,
9247 name, 10650 new IncDecCompound(CompoundKind.PREFIX, operator),
9248 new IncDecCompound(CompoundKind.POSTFIX, operator), 10651 arg,
9249 arg); 10652 isSetterValid: false);
9250 } 10653 }
9251 10654
9252 @override 10655 @override
9253 R visitStaticFieldPostfix( 10656 R visitFinalParameterPostfix(
10657 Send node,
10658 ParameterElement parameter,
10659 IncDecOperator operator,
10660 A arg) {
10661 return handleLocalCompounds(
10662 node,
10663 parameter,
10664 new IncDecCompound(CompoundKind.POSTFIX, operator),
10665 arg,
10666 isSetterValid: false);
10667 }
10668
10669 @override
10670 R visitFinalParameterPrefix(
10671 Send node,
10672 ParameterElement parameter,
10673 IncDecOperator operator,
10674 A arg) {
10675 return handleLocalCompounds(
10676 node,
10677 parameter,
10678 new IncDecCompound(CompoundKind.PREFIX, operator),
10679 arg,
10680 isSetterValid: false);
10681 }
10682
10683 @override
10684 R visitFinalStaticFieldPostfix(
9254 Send node, 10685 Send node,
9255 FieldElement field, 10686 FieldElement field,
9256 IncDecOperator operator, 10687 IncDecOperator operator,
9257 A arg) { 10688 A arg) {
9258 return handleStaticCompounds( 10689 return handleStaticCompounds(
9259 node, 10690 node,
9260 field, CompoundGetter.FIELD, 10691 field,
9261 field, CompoundSetter.FIELD, 10692 CompoundGetter.FIELD,
9262 new IncDecCompound(CompoundKind.POSTFIX, operator), 10693 field,
9263 arg); 10694 CompoundSetter.INVALID,
9264 } 10695 new IncDecCompound(CompoundKind.POSTFIX, operator),
9265 10696 arg);
9266 @override 10697 }
9267 R visitStaticGetterSetterPostfix( 10698
9268 Send node, 10699 @override
9269 FunctionElement getter, 10700 R visitFinalStaticFieldPrefix(
9270 FunctionElement setter,
9271 IncDecOperator operator,
9272 A arg) {
9273 return handleStaticCompounds(
9274 node,
9275 getter, CompoundGetter.GETTER,
9276 setter, CompoundSetter.SETTER,
9277 new IncDecCompound(CompoundKind.POSTFIX, operator),
9278 arg);
9279 }
9280
9281
9282 R visitStaticMethodSetterPostfix(
9283 Send node,
9284 FunctionElement getter,
9285 FunctionElement setter,
9286 IncDecOperator operator,
9287 A arg) {
9288 return handleStaticCompounds(
9289 node,
9290 getter, CompoundGetter.METHOD,
9291 setter, CompoundSetter.SETTER,
9292 new IncDecCompound(CompoundKind.POSTFIX, operator),
9293 arg);
9294 }
9295
9296 @override
9297 R visitTopLevelFieldPostfix(
9298 Send node, 10701 Send node,
9299 FieldElement field, 10702 FieldElement field,
9300 IncDecOperator operator, 10703 IncDecOperator operator,
9301 A arg) { 10704 A arg) {
9302 return handleStaticCompounds( 10705 return handleStaticCompounds(
9303 node, 10706 node,
9304 field, CompoundGetter.FIELD, 10707 field,
9305 field, CompoundSetter.FIELD, 10708 CompoundGetter.FIELD,
9306 new IncDecCompound(CompoundKind.POSTFIX, operator), 10709 field,
9307 arg); 10710 CompoundSetter.INVALID,
9308 } 10711 new IncDecCompound(CompoundKind.PREFIX, operator),
9309 10712 arg);
9310 @override 10713 }
9311 R visitTopLevelGetterSetterPostfix( 10714
9312 Send node, 10715 @override
9313 FunctionElement getter, 10716 R visitSuperFieldFieldCompound(
9314 FunctionElement setter,
9315 IncDecOperator operator,
9316 A arg) {
9317 return handleStaticCompounds(
9318 node,
9319 getter, CompoundGetter.GETTER,
9320 setter, CompoundSetter.SETTER,
9321 new IncDecCompound(CompoundKind.POSTFIX, operator),
9322 arg);
9323 }
9324
9325 @override
9326 R visitTopLevelMethodSetterPostfix(
9327 Send node,
9328 FunctionElement method,
9329 FunctionElement setter,
9330 IncDecOperator operator,
9331 A arg) {
9332 return handleStaticCompounds(
9333 node,
9334 method, CompoundGetter.METHOD,
9335 setter, CompoundSetter.SETTER,
9336 new IncDecCompound(CompoundKind.POSTFIX, operator),
9337 arg);
9338 }
9339
9340 @override
9341 R visitSuperFieldPostfix(
9342 Send node,
9343 FieldElement field,
9344 IncDecOperator operator,
9345 A arg) {
9346 return handleSuperCompounds(
9347 node,
9348 field, CompoundGetter.FIELD,
9349 field, CompoundSetter.FIELD,
9350 new IncDecCompound(CompoundKind.POSTFIX, operator),
9351 arg);
9352 }
9353
9354 @override
9355 R visitSuperFieldFieldPostfix(
9356 Send node, 10717 Send node,
9357 FieldElement readField, 10718 FieldElement readField,
9358 FieldElement writtenField, 10719 FieldElement writtenField,
9359 IncDecOperator operator, 10720 AssignmentOperator operator,
9360 A arg) { 10721 Node rhs,
9361 return handleSuperCompounds( 10722 A arg) {
9362 node, 10723 return handleSuperCompounds(
9363 readField, CompoundGetter.FIELD, 10724 node,
9364 writtenField, CompoundSetter.FIELD, 10725 readField,
9365 new IncDecCompound(CompoundKind.POSTFIX, operator), 10726 CompoundGetter.FIELD,
9366 arg); 10727 writtenField,
9367 } 10728 CompoundSetter.FIELD,
9368 10729 new AssignmentCompound(operator, rhs),
9369 @override 10730 arg);
9370 R visitSuperFieldSetterPostfix( 10731 }
10732
10733 @override
10734 R visitFinalSuperFieldPostfix(
9371 Send node, 10735 Send node,
9372 FieldElement field, 10736 FieldElement field,
9373 FunctionElement setter, 10737 IncDecOperator operator,
9374 IncDecOperator operator, 10738 A arg) {
9375 A arg) { 10739 return handleSuperCompounds(
9376 return handleSuperCompounds( 10740 node,
9377 node, 10741 field,
9378 field, CompoundGetter.FIELD, 10742 CompoundGetter.FIELD,
9379 setter, CompoundSetter.SETTER, 10743 field,
9380 new IncDecCompound(CompoundKind.POSTFIX, operator), 10744 CompoundSetter.INVALID,
9381 arg); 10745 new IncDecCompound(CompoundKind.POSTFIX, operator),
9382 } 10746 arg);
9383 10747 }
9384 10748
9385 R visitSuperGetterSetterPostfix( 10749 @override
9386 Send node, 10750 R visitFinalSuperFieldPrefix(
9387 FunctionElement getter, 10751 Send node,
9388 FunctionElement setter,
9389 IncDecOperator operator,
9390 A arg) {
9391 return handleSuperCompounds(
9392 node,
9393 getter, CompoundGetter.GETTER,
9394 setter, CompoundSetter.SETTER,
9395 new IncDecCompound(CompoundKind.POSTFIX, operator),
9396 arg);
9397 }
9398
9399 @override
9400 R visitSuperGetterFieldPostfix(
9401 Send node,
9402 FunctionElement getter,
9403 FieldElement field, 10752 FieldElement field,
9404 IncDecOperator operator, 10753 IncDecOperator operator,
9405 A arg) { 10754 A arg) {
9406 return handleSuperCompounds( 10755 return handleSuperCompounds(
9407 node, 10756 node,
9408 getter, CompoundGetter.GETTER, 10757 field,
9409 field, CompoundSetter.FIELD, 10758 CompoundGetter.FIELD,
9410 new IncDecCompound(CompoundKind.POSTFIX, operator), 10759 field,
9411 arg); 10760 CompoundSetter.INVALID,
9412 } 10761 new IncDecCompound(CompoundKind.PREFIX, operator),
9413 10762 arg);
9414 @override 10763 }
9415 R visitSuperMethodSetterPostfix( 10764
10765 @override
10766 R visitSuperMethodCompound(
9416 Send node, 10767 Send node,
9417 FunctionElement method, 10768 FunctionElement method,
9418 FunctionElement setter, 10769 AssignmentOperator operator,
9419 IncDecOperator operator, 10770 Node rhs,
9420 A arg) { 10771 A arg) {
9421 return handleSuperCompounds( 10772 return handleSuperCompounds(
9422 node, 10773 node,
9423 method, CompoundGetter.METHOD, 10774 method,
9424 setter, CompoundSetter.SETTER, 10775 CompoundGetter.METHOD,
9425 new IncDecCompound(CompoundKind.POSTFIX, operator), 10776 method,
9426 arg); 10777 CompoundSetter.INVALID,
9427 } 10778 new AssignmentCompound(operator, rhs),
9428 10779 arg);
9429 @override 10780 }
9430 R visitClassTypeLiteralPostfix( 10781
9431 Send node, 10782 @override
9432 ConstantExpression constant, 10783 R visitSuperMethodPostfix(
9433 IncDecOperator operator, 10784 Send node,
9434 A arg) { 10785 FunctionElement method,
9435 return handleTypeLiteralConstantCompounds( 10786 IncDecOperator operator,
9436 node, 10787 A arg) {
9437 constant, 10788 return handleSuperCompounds(
9438 new IncDecCompound(CompoundKind.POSTFIX, operator), 10789 node,
9439 arg); 10790 method,
9440 } 10791 CompoundGetter.METHOD,
9441 10792 method,
9442 @override 10793 CompoundSetter.INVALID,
9443 R visitTypedefTypeLiteralPostfix( 10794 new IncDecCompound(CompoundKind.POSTFIX, operator),
9444 Send node, 10795 arg);
9445 ConstantExpression constant, 10796 }
9446 IncDecOperator operator, 10797
9447 A arg) { 10798 @override
9448 return handleTypeLiteralConstantCompounds( 10799 R visitSuperMethodPrefix(
9449 node, 10800 Send node,
9450 constant, 10801 FunctionElement method,
9451 new IncDecCompound(CompoundKind.POSTFIX, operator), 10802 IncDecOperator operator,
9452 arg); 10803 A arg) {
9453 } 10804 return handleSuperCompounds(
9454 10805 node,
9455 @override 10806 method,
9456 R visitTypeVariableTypeLiteralPostfix( 10807 CompoundGetter.METHOD,
9457 Send node, 10808 method,
9458 TypeVariableElement element, 10809 CompoundSetter.INVALID,
9459 IncDecOperator operator, 10810 new IncDecCompound(CompoundKind.PREFIX, operator),
9460 A arg) { 10811 arg);
9461 return handleTypeVariableTypeLiteralCompounds( 10812 }
9462 node, 10813
9463 element, 10814 @override
9464 new IncDecCompound(CompoundKind.POSTFIX, operator), 10815 R visitFinalTopLevelFieldPostfix(
9465 arg); 10816 Send node,
9466 } 10817 FieldElement field,
9467 10818 IncDecOperator operator,
9468 @override 10819 A arg) {
9469 R visitDynamicTypeLiteralPostfix( 10820 return handleStaticCompounds(
9470 Send node, 10821 node,
9471 ConstantExpression constant, 10822 field,
9472 IncDecOperator operator, 10823 CompoundGetter.FIELD,
9473 A arg) { 10824 field,
9474 return handleTypeLiteralConstantCompounds( 10825 CompoundSetter.INVALID,
9475 node, 10826 new IncDecCompound(CompoundKind.POSTFIX, operator),
9476 constant, 10827 arg);
9477 new IncDecCompound(CompoundKind.POSTFIX, operator), 10828 }
9478 arg); 10829
9479 } 10830 @override
9480 10831 R visitFinalTopLevelFieldPrefix(
9481 @override 10832 Send node,
9482 R visitUnresolvedStaticGetterPostfix( 10833 FieldElement field,
9483 Send node, 10834 IncDecOperator operator,
9484 Element element, 10835 A arg) {
10836 return handleStaticCompounds(
10837 node,
10838 field,
10839 CompoundGetter.FIELD,
10840 field,
10841 CompoundSetter.INVALID,
10842 new IncDecCompound(CompoundKind.PREFIX, operator),
10843 arg);
10844 }
10845
10846 @override
10847 R visitUnresolvedSuperCompound(
10848 Send node,
10849 Element element,
10850 AssignmentOperator operator,
10851 Node rhs,
10852 A arg) {
10853 return handleSuperCompounds(
10854 node,
10855 element,
10856 CompoundGetter.UNRESOLVED,
10857 element,
10858 CompoundSetter.INVALID,
10859 new AssignmentCompound(operator, rhs),
10860 arg);
10861 }
10862
10863 @override
10864 R visitUnresolvedSuperPostfix(
10865 Send node,
10866 Element element,
10867 IncDecOperator operator,
10868 A arg) {
10869 return handleSuperCompounds(
10870 node,
10871 element,
10872 CompoundGetter.UNRESOLVED,
10873 element,
10874 CompoundSetter.INVALID,
10875 new IncDecCompound(CompoundKind.POSTFIX, operator),
10876 arg);
10877 }
10878
10879 @override
10880 R visitUnresolvedSuperPrefix(
10881 Send node,
10882 Element element,
10883 IncDecOperator operator,
10884 A arg) {
10885 return handleSuperCompounds(
10886 node,
10887 element,
10888 CompoundGetter.UNRESOLVED,
10889 element,
10890 CompoundSetter.INVALID,
10891 new IncDecCompound(CompoundKind.PREFIX, operator),
10892 arg);
10893 }
10894
10895 @override
10896 R visitUnresolvedSuperGetterCompound(
10897 Send node, Element element,
9485 MethodElement setter, 10898 MethodElement setter,
9486 IncDecOperator operator, 10899 AssignmentOperator operator,
9487 A arg) { 10900 Node rhs,
9488 return handleStaticCompounds( 10901 A arg) {
10902 return handleSuperCompounds(
9489 node, 10903 node,
9490 element, 10904 element,
9491 CompoundGetter.UNRESOLVED, 10905 CompoundGetter.UNRESOLVED,
9492 setter, 10906 setter,
9493 CompoundSetter.SETTER, 10907 CompoundSetter.SETTER,
9494 new IncDecCompound(CompoundKind.POSTFIX, operator), 10908 new AssignmentCompound(operator, rhs),
9495 arg); 10909 arg);
9496 } 10910 }
9497 10911
9498 @override 10912 @override
9499 R visitUnresolvedTopLevelGetterPostfix( 10913 R visitUnresolvedSuperGetterPostfix(
9500 Send node, 10914 Send node,
9501 Element element, 10915 Element element,
9502 MethodElement setter, 10916 MethodElement setter,
9503 IncDecOperator operator, 10917 IncDecOperator operator,
9504 A arg) { 10918 A arg) {
9505 return handleStaticCompounds( 10919 return handleSuperCompounds(
9506 node, 10920 node,
9507 element, 10921 element,
9508 CompoundGetter.UNRESOLVED, 10922 CompoundGetter.UNRESOLVED,
9509 setter, 10923 setter,
9510 CompoundSetter.SETTER, 10924 CompoundSetter.SETTER,
9511 new IncDecCompound(CompoundKind.POSTFIX, operator), 10925 new IncDecCompound(CompoundKind.POSTFIX, operator),
9512 arg); 10926 arg);
9513 } 10927 }
9514 10928
9515 @override 10929 @override
9516 R visitUnresolvedStaticSetterPostfix( 10930 R visitUnresolvedSuperGetterPrefix(
9517 Send node,
9518 MethodElement getter,
9519 Element element,
9520 IncDecOperator operator,
9521 A arg) {
9522 return handleStaticCompounds(
9523 node,
9524 getter,
9525 CompoundGetter.GETTER,
9526 element,
9527 CompoundSetter.INVALID,
9528 new IncDecCompound(CompoundKind.POSTFIX, operator),
9529 arg);
9530 }
9531
9532 @override
9533 R visitUnresolvedTopLevelSetterPostfix(
9534 Send node,
9535 MethodElement getter,
9536 Element element,
9537 IncDecOperator operator,
9538 A arg) {
9539 return handleStaticCompounds(
9540 node,
9541 getter,
9542 CompoundGetter.GETTER,
9543 element,
9544 CompoundSetter.INVALID,
9545 new IncDecCompound(CompoundKind.POSTFIX, operator),
9546 arg);
9547 }
9548
9549 @override
9550 R visitStaticMethodPostfix(
9551 Send node,
9552 MethodElement method,
9553 IncDecOperator operator,
9554 A arg) {
9555 return handleStaticCompounds(
9556 node,
9557 method,
9558 CompoundGetter.METHOD,
9559 method,
9560 CompoundSetter.INVALID,
9561 new IncDecCompound(CompoundKind.POSTFIX, operator),
9562 arg);
9563 }
9564
9565 @override
9566 R visitTopLevelMethodPostfix(
9567 Send node,
9568 MethodElement method,
9569 IncDecOperator operator,
9570 A arg) {
9571 return handleStaticCompounds(
9572 node,
9573 method,
9574 CompoundGetter.METHOD,
9575 method,
9576 CompoundSetter.INVALID,
9577 new IncDecCompound(CompoundKind.POSTFIX, operator),
9578 arg);
9579 }
9580
9581 @override
9582 R visitUnresolvedPostfix(
9583 Send node,
9584 Element element,
9585 IncDecOperator operator,
9586 A arg) {
9587 return handleStaticCompounds(
9588 node,
9589 element,
9590 CompoundGetter.UNRESOLVED,
9591 element,
9592 CompoundSetter.INVALID,
9593 new IncDecCompound(CompoundKind.POSTFIX, operator),
9594 arg);
9595 }
9596
9597 @override
9598 R visitUnresolvedStaticGetterPrefix(
9599 Send node, 10931 Send node,
9600 Element element, 10932 Element element,
9601 MethodElement setter, 10933 MethodElement setter,
9602 IncDecOperator operator, 10934 IncDecOperator operator,
9603 A arg) { 10935 A arg) {
9604 return handleStaticCompounds( 10936 return handleSuperCompounds(
9605 node, 10937 node,
9606 element, 10938 element,
9607 CompoundGetter.UNRESOLVED, 10939 CompoundGetter.UNRESOLVED,
9608 setter,
9609 CompoundSetter.SETTER,
9610 new IncDecCompound(CompoundKind.PREFIX, operator),
9611 arg);
9612 }
9613
9614 @override
9615 R visitUnresolvedTopLevelGetterPrefix(
9616 Send node,
9617 Element element,
9618 MethodElement setter,
9619 IncDecOperator operator,
9620 A arg) {
9621 return handleStaticCompounds(
9622 node,
9623 element,
9624 CompoundGetter.UNRESOLVED,
9625 setter, 10940 setter,
9626 CompoundSetter.SETTER, 10941 CompoundSetter.SETTER,
9627 new IncDecCompound(CompoundKind.PREFIX, operator), 10942 new IncDecCompound(CompoundKind.PREFIX, operator),
9628 arg); 10943 arg);
9629 } 10944 }
9630 10945
9631 @override 10946 @override
9632 R visitUnresolvedStaticSetterPrefix( 10947 R visitUnresolvedSuperSetterCompound(
9633 Send node, 10948 Send node,
9634 MethodElement getter, 10949 MethodElement getter,
9635 Element element, 10950 Element element,
10951 AssignmentOperator operator,
10952 Node rhs,
10953 A arg) {
10954 return handleSuperCompounds(
10955 node,
10956 getter,
10957 CompoundGetter.GETTER,
10958 element,
10959 CompoundSetter.INVALID,
10960 new AssignmentCompound(operator, rhs),
10961 arg);
10962 }
10963
10964 @override
10965 R visitUnresolvedSuperSetterPostfix(
10966 Send node,
10967 MethodElement getter,
10968 Element element,
9636 IncDecOperator operator, 10969 IncDecOperator operator,
9637 A arg) { 10970 A arg) {
9638 return handleStaticCompounds( 10971 return handleSuperCompounds(
10972 node,
10973 getter,
10974 CompoundGetter.GETTER,
10975 element,
10976 CompoundSetter.INVALID,
10977 new IncDecCompound(CompoundKind.POSTFIX, operator),
10978 arg);
10979 }
10980
10981 @override
10982 R visitUnresolvedSuperSetterPrefix(
10983 Send node,
10984 MethodElement getter,
10985 Element element,
10986 IncDecOperator operator,
10987 A arg) {
10988 return handleSuperCompounds(
9639 node, 10989 node,
9640 getter, 10990 getter,
9641 CompoundGetter.GETTER, 10991 CompoundGetter.GETTER,
9642 element, 10992 element,
9643 CompoundSetter.INVALID, 10993 CompoundSetter.INVALID,
9644 new IncDecCompound(CompoundKind.PREFIX, operator), 10994 new IncDecCompound(CompoundKind.PREFIX, operator),
9645 arg); 10995 arg);
9646 } 10996 }
9647 10997 }
9648 @override 10998
9649 R visitUnresolvedTopLevelSetterPrefix( 10999 /// Simplified handling of if-null assignments.
9650 Send node, 11000 abstract class BaseImplementationOfSetIfNullsMixin<R, A>
9651 MethodElement getter, 11001 implements SemanticSendVisitor<R, A> {
9652 Element element, 11002
9653 IncDecOperator operator, 11003 /// Handle a super if-null assignments, like `super.foo ??= 42`.
9654 A arg) { 11004 R handleSuperSetIfNulls(
9655 return handleStaticCompounds( 11005 SendSet node,
9656 node, 11006 Element getter,
9657 getter, 11007 CompoundGetter getterKind,
9658 CompoundGetter.GETTER, 11008 Element setter,
9659 element, 11009 CompoundSetter setterKind,
9660 CompoundSetter.INVALID, 11010 Node rhs,
9661 new IncDecCompound(CompoundKind.PREFIX, operator), 11011 A arg);
9662 arg); 11012
9663 } 11013 /// Handle a static or top level if-null assignments, like `foo ??= 42`.
9664 11014 R handleStaticSetIfNulls(
9665 @override 11015 SendSet node,
9666 R visitStaticMethodPrefix( 11016 Element getter,
11017 CompoundGetter getterKind,
11018 Element setter,
11019 CompoundSetter setterKind,
11020 Node rhs,
11021 A arg);
11022
11023 /// Handle a local if-null assignments, like `foo ??= 42`. If [isSetterValid]
11024 /// is false [local] is unassignable.
11025 R handleLocalSetIfNulls(
11026 SendSet node,
11027 LocalElement local,
11028 Node rhs,
11029 A arg,
11030 {bool isSetterValid});
11031
11032 /// Handle a if-null assignments on a type literal constant, like
11033 /// `Object ??= 42`.
11034 R handleTypeLiteralConstantSetIfNulls(
11035 SendSet node,
11036 ConstantExpression constant,
11037 Node rhs,
11038 A arg);
11039
11040 /// Handle a dynamic if-null assignments, like `o.foo ??= 42`. [receiver] is
11041 /// `null` for properties on `this`, like `this.foo ??= 42` or `foo ??= 42`.
11042 R handleDynamicSetIfNulls(
11043 Send node,
11044 Node receiver,
11045 Name name,
11046 Node rhs,
11047 A arg);
11048
11049 @override
11050 R visitClassTypeLiteralSetIfNull(
11051 Send node,
11052 ConstantExpression constant,
11053 Node rhs,
11054 A arg) {
11055 return handleTypeLiteralConstantSetIfNulls(node, constant, rhs, arg);
11056 }
11057
11058 @override
11059 R visitDynamicPropertySetIfNull(
11060 Send node,
11061 Node receiver,
11062 Name name,
11063 Node rhs,
11064 A arg) {
11065 return handleDynamicSetIfNulls(node, receiver, name, rhs, arg);
11066 }
11067
11068 @override
11069 R visitDynamicTypeLiteralSetIfNull(
11070 Send node,
11071 ConstantExpression constant,
11072 Node rhs,
11073 A arg) {
11074 return handleTypeLiteralConstantSetIfNulls(node, constant, rhs, arg);
11075 }
11076
11077 @override
11078 R visitFinalLocalVariableSetIfNull(
11079 Send node,
11080 LocalVariableElement variable,
11081 Node rhs,
11082 A arg) {
11083 return handleLocalSetIfNulls(
11084 node, variable, rhs, arg, isSetterValid: false);
11085 }
11086
11087 @override
11088 R visitFinalParameterSetIfNull(
11089 Send node,
11090 ParameterElement parameter,
11091 Node rhs,
11092 A arg) {
11093 return handleLocalSetIfNulls(
11094 node, parameter, rhs, arg, isSetterValid: false);
11095 }
11096
11097 @override
11098 R visitFinalStaticFieldSetIfNull(
11099 Send node,
11100 FieldElement field,
11101 Node rhs,
11102 A arg) {
11103 return handleStaticSetIfNulls(
11104 node,
11105 field,
11106 CompoundGetter.FIELD,
11107 field,
11108 CompoundSetter.INVALID,
11109 rhs,
11110 arg);
11111 }
11112
11113 @override
11114 R visitFinalSuperFieldSetIfNull(
11115 Send node,
11116 FieldElement field,
11117 Node rhs,
11118 A arg) {
11119 return handleSuperSetIfNulls(
11120 node,
11121 field,
11122 CompoundGetter.FIELD,
11123 field,
11124 CompoundSetter.INVALID,
11125 rhs,
11126 arg);
11127 }
11128
11129 @override
11130 R visitFinalTopLevelFieldSetIfNull(
11131 Send node,
11132 FieldElement field,
11133 Node rhs,
11134 A arg) {
11135 return handleStaticSetIfNulls(
11136 node,
11137 field,
11138 CompoundGetter.FIELD,
11139 field,
11140 CompoundSetter.INVALID,
11141 rhs,
11142 arg);
11143 }
11144
11145 @override
11146 R visitIfNotNullDynamicPropertySetIfNull(
11147 Send node,
11148 Node receiver,
11149 Name name,
11150 Node rhs,
11151 A arg) {
11152 return handleDynamicSetIfNulls(node, receiver, name, rhs, arg);
11153 }
11154
11155 @override
11156 R visitLocalFunctionSetIfNull(
11157 Send node,
11158 LocalFunctionElement function,
11159 Node rhs,
11160 A arg) {
11161 return handleLocalSetIfNulls(
11162 node, function, rhs, arg, isSetterValid: false);
11163 }
11164
11165 @override
11166 R visitLocalVariableSetIfNull(
11167 Send node,
11168 LocalVariableElement variable,
11169 Node rhs,
11170 A arg) {
11171 return handleLocalSetIfNulls(
11172 node, variable, rhs, arg, isSetterValid: true);
11173 }
11174
11175 @override
11176 R visitParameterSetIfNull(
11177 Send node,
11178 ParameterElement parameter,
11179 Node rhs,
11180 A arg) {
11181 return handleLocalSetIfNulls(
11182 node, parameter, rhs, arg, isSetterValid: true);
11183 }
11184
11185 @override
11186 R visitStaticFieldSetIfNull(
11187 Send node,
11188 FieldElement field,
11189 Node rhs,
11190 A arg) {
11191 return handleStaticSetIfNulls(
11192 node,
11193 field,
11194 CompoundGetter.FIELD,
11195 field,
11196 CompoundSetter.FIELD,
11197 rhs,
11198 arg);
11199 }
11200
11201 @override
11202 R visitStaticGetterSetterSetIfNull(
11203 Send node,
11204 FunctionElement getter,
11205 FunctionElement setter,
11206 Node rhs,
11207 A arg) {
11208 return handleStaticSetIfNulls(
11209 node,
11210 getter,
11211 CompoundGetter.GETTER,
11212 setter,
11213 CompoundSetter.SETTER,
11214 rhs,
11215 arg);
11216 }
11217
11218 @override
11219 R visitStaticMethodSetIfNull(
11220 Send node,
11221 FunctionElement method,
11222 Node rhs,
11223 A arg) {
11224 return handleStaticSetIfNulls(
11225 node,
11226 method,
11227 CompoundGetter.METHOD,
11228 method,
11229 CompoundSetter.INVALID,
11230 rhs,
11231 arg);
11232 }
11233
11234 @override
11235 R visitStaticMethodSetterSetIfNull(
9667 Send node, 11236 Send node,
9668 MethodElement method, 11237 MethodElement method,
9669 IncDecOperator operator, 11238 MethodElement setter,
9670 A arg) { 11239 Node rhs,
9671 return handleStaticCompounds( 11240 A arg) {
11241 return handleStaticSetIfNulls(
9672 node, 11242 node,
9673 method, 11243 method,
9674 CompoundGetter.METHOD, 11244 CompoundGetter.METHOD,
9675 method, 11245 setter,
9676 CompoundSetter.INVALID, 11246 CompoundSetter.SETTER,
9677 new IncDecCompound(CompoundKind.PREFIX, operator), 11247 rhs,
9678 arg); 11248 arg);
9679 } 11249 }
9680 11250
9681 @override 11251 @override
9682 R visitTopLevelMethodPrefix( 11252 R visitSuperFieldFieldSetIfNull(
9683 Send node,
9684 MethodElement method,
9685 IncDecOperator operator,
9686 A arg) {
9687 return handleStaticCompounds(
9688 node,
9689 method,
9690 CompoundGetter.METHOD,
9691 method,
9692 CompoundSetter.INVALID,
9693 new IncDecCompound(CompoundKind.PREFIX, operator),
9694 arg);
9695 }
9696
9697 @override
9698 R visitUnresolvedPrefix(
9699 Send node,
9700 Element element,
9701 IncDecOperator operator,
9702 A arg) {
9703 return handleStaticCompounds(
9704 node,
9705 element,
9706 CompoundGetter.UNRESOLVED,
9707 element,
9708 CompoundSetter.INVALID,
9709 new IncDecCompound(CompoundKind.PREFIX, operator),
9710 arg);
9711 }
9712
9713 @override
9714 R visitUnresolvedStaticGetterCompound(
9715 Send node,
9716 Element element,
9717 MethodElement setter,
9718 AssignmentOperator operator,
9719 Node rhs,
9720 A arg) {
9721 return handleStaticCompounds(
9722 node,
9723 element,
9724 CompoundGetter.UNRESOLVED,
9725 setter,
9726 CompoundSetter.SETTER,
9727 new AssignmentCompound(operator, rhs),
9728 arg);
9729 }
9730
9731 @override
9732 R visitUnresolvedTopLevelGetterCompound(
9733 Send node,
9734 Element element,
9735 MethodElement setter,
9736 AssignmentOperator operator,
9737 Node rhs,
9738 A arg) {
9739 return handleStaticCompounds(
9740 node,
9741 element,
9742 CompoundGetter.UNRESOLVED,
9743 setter,
9744 CompoundSetter.SETTER,
9745 new AssignmentCompound(operator, rhs),
9746 arg);
9747 }
9748
9749 @override
9750 R visitUnresolvedStaticSetterCompound(
9751 Send node,
9752 MethodElement getter,
9753 Element element,
9754 AssignmentOperator operator,
9755 Node rhs,
9756 A arg) {
9757 return handleStaticCompounds(
9758 node,
9759 getter,
9760 CompoundGetter.GETTER,
9761 element,
9762 CompoundSetter.INVALID,
9763 new AssignmentCompound(operator, rhs),
9764 arg);
9765 }
9766
9767 @override
9768 R visitUnresolvedTopLevelSetterCompound(
9769 Send node,
9770 MethodElement getter,
9771 Element element,
9772 AssignmentOperator operator,
9773 Node rhs,
9774 A arg) {
9775 return handleStaticCompounds(
9776 node,
9777 getter,
9778 CompoundGetter.GETTER,
9779 element,
9780 CompoundSetter.INVALID,
9781 new AssignmentCompound(operator, rhs),
9782 arg);
9783 }
9784
9785 @override
9786 R visitStaticMethodCompound(
9787 Send node,
9788 MethodElement method,
9789 AssignmentOperator operator,
9790 Node rhs,
9791 A arg) {
9792 return handleStaticCompounds(
9793 node,
9794 method,
9795 CompoundGetter.METHOD,
9796 method,
9797 CompoundSetter.INVALID,
9798 new AssignmentCompound(operator, rhs),
9799 arg);
9800 }
9801
9802 @override
9803 R visitTopLevelMethodCompound(
9804 Send node,
9805 MethodElement method,
9806 AssignmentOperator operator,
9807 Node rhs,
9808 A arg) {
9809 return handleStaticCompounds(
9810 node,
9811 method,
9812 CompoundGetter.METHOD,
9813 method,
9814 CompoundSetter.INVALID,
9815 new AssignmentCompound(operator, rhs),
9816 arg);
9817 }
9818
9819 @override
9820 R visitUnresolvedCompound(
9821 Send node,
9822 Element element,
9823 AssignmentOperator operator,
9824 Node rhs,
9825 A arg) {
9826 return handleStaticCompounds(
9827 node,
9828 element,
9829 CompoundGetter.UNRESOLVED,
9830 element,
9831 CompoundSetter.INVALID,
9832 new AssignmentCompound(operator, rhs),
9833 arg);
9834 }
9835
9836 @override
9837 R visitFinalLocalVariablePostfix(
9838 Send node,
9839 LocalVariableElement variable,
9840 IncDecOperator operator,
9841 A arg) {
9842 return handleLocalCompounds(
9843 node,
9844 variable,
9845 new IncDecCompound(CompoundKind.POSTFIX, operator),
9846 arg,
9847 isSetterValid: false);
9848 }
9849
9850 @override
9851 R visitFinalLocalVariablePrefix(
9852 Send node,
9853 LocalVariableElement variable,
9854 IncDecOperator operator,
9855 A arg) {
9856 return handleLocalCompounds(
9857 node,
9858 variable,
9859 new IncDecCompound(CompoundKind.PREFIX, operator),
9860 arg,
9861 isSetterValid: false);
9862 }
9863
9864 @override
9865 R visitFinalParameterPostfix(
9866 Send node,
9867 ParameterElement parameter,
9868 IncDecOperator operator,
9869 A arg) {
9870 return handleLocalCompounds(
9871 node,
9872 parameter,
9873 new IncDecCompound(CompoundKind.POSTFIX, operator),
9874 arg,
9875 isSetterValid: false);
9876 }
9877
9878 @override
9879 R visitFinalParameterPrefix(
9880 Send node,
9881 ParameterElement parameter,
9882 IncDecOperator operator,
9883 A arg) {
9884 return handleLocalCompounds(
9885 node,
9886 parameter,
9887 new IncDecCompound(CompoundKind.PREFIX, operator),
9888 arg,
9889 isSetterValid: false);
9890 }
9891
9892 @override
9893 R visitFinalStaticFieldPostfix(
9894 Send node,
9895 FieldElement field,
9896 IncDecOperator operator,
9897 A arg) {
9898 return handleStaticCompounds(
9899 node,
9900 field,
9901 CompoundGetter.FIELD,
9902 field,
9903 CompoundSetter.INVALID,
9904 new IncDecCompound(CompoundKind.POSTFIX, operator),
9905 arg);
9906 }
9907
9908 @override
9909 R visitFinalStaticFieldPrefix(
9910 Send node,
9911 FieldElement field,
9912 IncDecOperator operator,
9913 A arg) {
9914 return handleStaticCompounds(
9915 node,
9916 field,
9917 CompoundGetter.FIELD,
9918 field,
9919 CompoundSetter.INVALID,
9920 new IncDecCompound(CompoundKind.PREFIX, operator),
9921 arg);
9922 }
9923
9924 @override
9925 R visitSuperFieldFieldCompound(
9926 Send node, 11253 Send node,
9927 FieldElement readField, 11254 FieldElement readField,
9928 FieldElement writtenField, 11255 FieldElement writtenField,
9929 AssignmentOperator operator, 11256 Node rhs,
9930 Node rhs, 11257 A arg) {
9931 A arg) { 11258 return handleSuperSetIfNulls(
9932 return handleSuperCompounds(
9933 node, 11259 node,
9934 readField, 11260 readField,
9935 CompoundGetter.FIELD, 11261 CompoundGetter.FIELD,
9936 writtenField, 11262 writtenField,
9937 CompoundSetter.FIELD, 11263 CompoundSetter.FIELD,
9938 new AssignmentCompound(operator, rhs), 11264 rhs,
9939 arg); 11265 arg);
9940 } 11266 }
9941 11267
9942 @override 11268 @override
9943 R visitFinalSuperFieldPostfix( 11269 R visitSuperFieldSetIfNull(
9944 Send node, 11270 Send node,
9945 FieldElement field, 11271 FieldElement field,
9946 IncDecOperator operator, 11272 Node rhs,
9947 A arg) { 11273 A arg) {
9948 return handleSuperCompounds( 11274 return handleSuperSetIfNulls(
9949 node, 11275 node,
9950 field, 11276 field,
9951 CompoundGetter.FIELD, 11277 CompoundGetter.FIELD,
9952 field, 11278 field,
9953 CompoundSetter.INVALID, 11279 CompoundSetter.FIELD,
9954 new IncDecCompound(CompoundKind.POSTFIX, operator), 11280 rhs,
9955 arg); 11281 arg);
9956 } 11282 }
9957 11283
9958 @override 11284 @override
9959 R visitFinalSuperFieldPrefix( 11285 R visitSuperFieldSetterSetIfNull(
9960 Send node, 11286 Send node,
9961 FieldElement field, 11287 FieldElement field,
9962 IncDecOperator operator, 11288 FunctionElement setter,
9963 A arg) { 11289 Node rhs,
9964 return handleSuperCompounds( 11290 A arg) {
9965 node, 11291 return handleSuperSetIfNulls(
9966 field, 11292 node,
9967 CompoundGetter.FIELD, 11293 field,
9968 field, 11294 CompoundGetter.FIELD,
9969 CompoundSetter.INVALID, 11295 setter,
9970 new IncDecCompound(CompoundKind.PREFIX, operator), 11296 CompoundSetter.SETTER,
9971 arg); 11297 rhs,
9972 } 11298 arg);
9973 11299 }
9974 @override 11300
9975 R visitSuperMethodCompound( 11301 @override
11302 R visitSuperGetterFieldSetIfNull(
11303 Send node,
11304 FunctionElement getter,
11305 FieldElement field,
11306 Node rhs,
11307 A arg) {
11308 return handleSuperSetIfNulls(
11309 node,
11310 getter,
11311 CompoundGetter.GETTER,
11312 field,
11313 CompoundSetter.FIELD,
11314 rhs,
11315 arg);
11316 }
11317
11318 @override
11319 R visitSuperGetterSetterSetIfNull(
11320 Send node,
11321 FunctionElement getter,
11322 FunctionElement setter,
11323 Node rhs,
11324 A arg) {
11325 return handleSuperSetIfNulls(
11326 node,
11327 getter,
11328 CompoundGetter.GETTER,
11329 setter,
11330 CompoundSetter.SETTER,
11331 rhs,
11332 arg);
11333 }
11334
11335 @override
11336 R visitSuperMethodSetIfNull(
9976 Send node, 11337 Send node,
9977 FunctionElement method, 11338 FunctionElement method,
9978 AssignmentOperator operator, 11339 Node rhs,
9979 Node rhs, 11340 A arg) {
9980 A arg) { 11341 return handleSuperSetIfNulls(
9981 return handleSuperCompounds(
9982 node, 11342 node,
9983 method, 11343 method,
9984 CompoundGetter.METHOD, 11344 CompoundGetter.METHOD,
9985 method, 11345 method,
9986 CompoundSetter.INVALID, 11346 CompoundSetter.INVALID,
9987 new AssignmentCompound(operator, rhs), 11347 rhs,
9988 arg); 11348 arg);
9989 } 11349 }
9990 11350
9991 @override 11351 @override
9992 R visitSuperMethodPostfix( 11352 R visitSuperMethodSetterSetIfNull(
9993 Send node, 11353 Send node,
9994 FunctionElement method, 11354 FunctionElement method,
9995 IncDecOperator operator, 11355 FunctionElement setter,
9996 A arg) { 11356 Node rhs,
9997 return handleSuperCompounds( 11357 A arg) {
11358 return handleSuperSetIfNulls(
9998 node, 11359 node,
9999 method, 11360 method,
10000 CompoundGetter.METHOD, 11361 CompoundGetter.METHOD,
10001 method, 11362 setter,
10002 CompoundSetter.INVALID, 11363 CompoundSetter.SETTER,
10003 new IncDecCompound(CompoundKind.POSTFIX, operator), 11364 rhs,
10004 arg); 11365 arg);
10005 } 11366 }
10006 11367
10007 @override 11368 @override
10008 R visitSuperMethodPrefix( 11369 R visitThisPropertySetIfNull(
11370 Send node,
11371 Name name,
11372 Node rhs,
11373 A arg) {
11374 return handleDynamicSetIfNulls(node, null, name, rhs, arg);
11375 }
11376
11377 @override
11378 R visitTopLevelFieldSetIfNull(
11379 Send node,
11380 FieldElement field,
11381 Node rhs,
11382 A arg) {
11383 return handleStaticSetIfNulls(
11384 node,
11385 field,
11386 CompoundGetter.FIELD,
11387 field,
11388 CompoundSetter.FIELD,
11389 rhs,
11390 arg);
11391 }
11392
11393 @override
11394 R visitTopLevelGetterSetterSetIfNull(
11395 Send node,
11396 FunctionElement getter,
11397 FunctionElement setter,
11398 Node rhs,
11399 A arg) {
11400 return handleStaticSetIfNulls(
11401 node,
11402 getter,
11403 CompoundGetter.GETTER,
11404 setter,
11405 CompoundSetter.SETTER,
11406 rhs,
11407 arg);
11408 }
11409
11410 @override
11411 R visitTopLevelMethodSetIfNull(
10009 Send node, 11412 Send node,
10010 FunctionElement method, 11413 FunctionElement method,
10011 IncDecOperator operator, 11414 Node rhs,
10012 A arg) { 11415 A arg) {
10013 return handleSuperCompounds( 11416 return handleStaticSetIfNulls(
10014 node, 11417 node,
10015 method, 11418 method,
10016 CompoundGetter.METHOD, 11419 CompoundGetter.METHOD,
10017 method, 11420 method,
10018 CompoundSetter.INVALID, 11421 CompoundSetter.INVALID,
10019 new IncDecCompound(CompoundKind.PREFIX, operator), 11422 rhs,
10020 arg); 11423 arg);
10021 } 11424 }
10022 11425
10023 @override 11426 @override
10024 R visitFinalTopLevelFieldPostfix( 11427 R visitTopLevelMethodSetterSetIfNull(
10025 Send node, 11428 Send node,
10026 FieldElement field, 11429 FunctionElement method,
10027 IncDecOperator operator, 11430 FunctionElement setter,
10028 A arg) { 11431 Node rhs,
10029 return handleStaticCompounds( 11432 A arg) {
10030 node, 11433 return handleStaticSetIfNulls(
10031 field, 11434 node,
10032 CompoundGetter.FIELD, 11435 method,
10033 field, 11436 CompoundGetter.METHOD,
10034 CompoundSetter.INVALID, 11437 setter,
10035 new IncDecCompound(CompoundKind.POSTFIX, operator), 11438 CompoundSetter.SETTER,
10036 arg); 11439 rhs,
10037 } 11440 arg);
10038 11441 }
10039 @override 11442
10040 R visitFinalTopLevelFieldPrefix( 11443 @override
10041 Send node, 11444 R visitTypedefTypeLiteralSetIfNull(
10042 FieldElement field, 11445 Send node,
10043 IncDecOperator operator, 11446 ConstantExpression constant,
10044 A arg) { 11447 Node rhs,
10045 return handleStaticCompounds( 11448 A arg) {
10046 node, 11449 return handleTypeLiteralConstantSetIfNulls(node, constant, rhs, arg);
10047 field, 11450 }
10048 CompoundGetter.FIELD, 11451
10049 field, 11452 @override
10050 CompoundSetter.INVALID, 11453 R visitUnresolvedSetIfNull(
10051 new IncDecCompound(CompoundKind.PREFIX, operator), 11454 Send node,
10052 arg); 11455 Element element,
10053 } 11456 Node rhs,
10054 11457 A arg) {
10055 @override 11458 return handleStaticSetIfNulls(
10056 R visitUnresolvedSuperCompound(
10057 Send node,
10058 Element element,
10059 AssignmentOperator operator,
10060 Node rhs,
10061 A arg) {
10062 return handleSuperCompounds(
10063 node, 11459 node,
10064 element, 11460 element,
10065 CompoundGetter.UNRESOLVED, 11461 CompoundGetter.UNRESOLVED,
10066 element, 11462 element,
10067 CompoundSetter.INVALID, 11463 CompoundSetter.INVALID,
10068 new AssignmentCompound(operator, rhs), 11464 rhs,
10069 arg); 11465 arg);
10070 } 11466 }
10071 11467
10072 @override 11468 @override
10073 R visitUnresolvedSuperPostfix( 11469 R visitUnresolvedStaticGetterSetIfNull(
10074 Send node, 11470 Send node,
10075 Element element, 11471 Element element,
10076 IncDecOperator operator, 11472 MethodElement setter,
10077 A arg) { 11473 Node rhs,
10078 return handleSuperCompounds( 11474 A arg) {
11475 return handleStaticSetIfNulls(
10079 node, 11476 node,
10080 element, 11477 element,
10081 CompoundGetter.UNRESOLVED, 11478 CompoundGetter.UNRESOLVED,
10082 element, 11479 setter,
10083 CompoundSetter.INVALID, 11480 CompoundSetter.SETTER,
10084 new IncDecCompound(CompoundKind.POSTFIX, operator), 11481 rhs,
10085 arg); 11482 arg);
10086 } 11483 }
10087 11484
10088 @override 11485 @override
10089 R visitUnresolvedSuperPrefix( 11486 R visitUnresolvedStaticSetterSetIfNull(
10090 Send node, 11487 Send node,
10091 Element element, 11488 MethodElement getter,
10092 IncDecOperator operator, 11489 Element element,
10093 A arg) { 11490 Node rhs,
10094 return handleSuperCompounds( 11491 A arg) {
11492 return handleStaticSetIfNulls(
11493 node,
11494 getter,
11495 CompoundGetter.GETTER,
11496 element,
11497 CompoundSetter.INVALID,
11498 rhs,
11499 arg);
11500 }
11501
11502 @override
11503 R visitUnresolvedSuperGetterSetIfNull(
11504 Send node,
11505 Element element,
11506 MethodElement setter,
11507 Node rhs,
11508 A arg) {
11509 return handleSuperSetIfNulls(
10095 node, 11510 node,
10096 element, 11511 element,
10097 CompoundGetter.UNRESOLVED, 11512 CompoundGetter.UNRESOLVED,
10098 element, 11513 setter,
10099 CompoundSetter.INVALID, 11514 CompoundSetter.SETTER,
10100 new IncDecCompound(CompoundKind.PREFIX, operator), 11515 rhs,
10101 arg); 11516 arg);
10102 } 11517 }
10103 11518
10104 @override 11519 @override
10105 R visitUnresolvedSuperGetterCompound( 11520 R visitUnresolvedSuperSetIfNull(
10106 Send node, Element element, 11521 Send node,
11522 Element element,
11523 Node rhs,
11524 A arg) {
11525 return handleSuperSetIfNulls(
11526 node,
11527 element,
11528 CompoundGetter.UNRESOLVED,
11529 element,
11530 CompoundSetter.INVALID,
11531 rhs,
11532 arg);
11533 }
11534
11535 @override
11536 R visitUnresolvedSuperSetterSetIfNull(
11537 Send node,
11538 MethodElement getter,
11539 Element element,
11540 Node rhs,
11541 A arg) {
11542 return handleSuperSetIfNulls(
11543 node,
11544 getter,
11545 CompoundGetter.GETTER,
11546 element,
11547 CompoundSetter.INVALID,
11548 rhs,
11549 arg);
11550 }
11551
11552 @override
11553 R visitUnresolvedTopLevelGetterSetIfNull(
11554 Send node,
11555 Element element,
10107 MethodElement setter, 11556 MethodElement setter,
10108 AssignmentOperator operator, 11557 Node rhs,
10109 Node rhs, 11558 A arg) {
10110 A arg) { 11559 return handleStaticSetIfNulls(
10111 return handleSuperCompounds(
10112 node, 11560 node,
10113 element, 11561 element,
10114 CompoundGetter.UNRESOLVED, 11562 CompoundGetter.UNRESOLVED,
10115 setter, 11563 setter,
10116 CompoundSetter.SETTER, 11564 CompoundSetter.SETTER,
10117 new AssignmentCompound(operator, rhs), 11565 rhs,
10118 arg); 11566 arg);
10119 } 11567 }
10120 11568
10121 @override 11569 @override
10122 R visitUnresolvedSuperGetterPostfix( 11570 R visitUnresolvedTopLevelSetterSetIfNull(
10123 Send node,
10124 Element element,
10125 MethodElement setter,
10126 IncDecOperator operator,
10127 A arg) {
10128 return handleSuperCompounds(
10129 node,
10130 element,
10131 CompoundGetter.UNRESOLVED,
10132 setter,
10133 CompoundSetter.SETTER,
10134 new IncDecCompound(CompoundKind.POSTFIX, operator),
10135 arg);
10136 }
10137
10138 @override
10139 R visitUnresolvedSuperGetterPrefix(
10140 Send node,
10141 Element element,
10142 MethodElement setter,
10143 IncDecOperator operator,
10144 A arg) {
10145 return handleSuperCompounds(
10146 node,
10147 element,
10148 CompoundGetter.UNRESOLVED,
10149 setter,
10150 CompoundSetter.SETTER,
10151 new IncDecCompound(CompoundKind.PREFIX, operator),
10152 arg);
10153 }
10154
10155 @override
10156 R visitUnresolvedSuperSetterCompound(
10157 Send node, 11571 Send node,
10158 MethodElement getter, 11572 MethodElement getter,
10159 Element element, 11573 Element element,
10160 AssignmentOperator operator, 11574 Node rhs,
10161 Node rhs, 11575 A arg) {
10162 A arg) { 11576 return handleStaticSetIfNulls(
10163 return handleSuperCompounds( 11577 node,
10164 node, 11578 getter,
10165 getter, 11579 CompoundGetter.GETTER,
10166 CompoundGetter.GETTER, 11580 element,
10167 element, 11581 CompoundSetter.INVALID,
10168 CompoundSetter.INVALID, 11582 rhs,
10169 new AssignmentCompound(operator, rhs),
10170 arg);
10171 }
10172
10173 @override
10174 R visitUnresolvedSuperSetterPostfix(
10175 Send node,
10176 MethodElement getter,
10177 Element element,
10178 IncDecOperator operator,
10179 A arg) {
10180 return handleSuperCompounds(
10181 node,
10182 getter,
10183 CompoundGetter.GETTER,
10184 element,
10185 CompoundSetter.INVALID,
10186 new IncDecCompound(CompoundKind.POSTFIX, operator),
10187 arg);
10188 }
10189
10190 @override
10191 R visitUnresolvedSuperSetterPrefix(
10192 Send node,
10193 MethodElement getter,
10194 Element element,
10195 IncDecOperator operator,
10196 A arg) {
10197 return handleSuperCompounds(
10198 node,
10199 getter,
10200 CompoundGetter.GETTER,
10201 element,
10202 CompoundSetter.INVALID,
10203 new IncDecCompound(CompoundKind.PREFIX, operator),
10204 arg); 11583 arg);
10205 } 11584 }
10206 } 11585 }
10207 11586
10208 /// Simplified handling of indexed compound assignments and prefix/postfix 11587 /// Simplified handling of indexed compound assignments and prefix/postfix
10209 /// expressions. 11588 /// expressions.
10210 abstract class BaseImplementationOfIndexCompoundsMixin<R, A> 11589 abstract class BaseImplementationOfIndexCompoundsMixin<R, A>
10211 implements SemanticSendVisitor<R, A> { 11590 implements SemanticSendVisitor<R, A> {
10212 11591
10213 /// Handle a dynamic index compounds, like `receiver[index] += rhs` or 11592 /// Handle a dynamic index compounds, like `receiver[index] += rhs` or
(...skipping 782 matching lines...) Expand 10 before | Expand all | Expand 10 after
10996 NewExpression node, 12375 NewExpression node,
10997 ConstructorElement constructor, 12376 ConstructorElement constructor,
10998 InterfaceType type, 12377 InterfaceType type,
10999 NodeList arguments, 12378 NodeList arguments,
11000 CallStructure callStructure, 12379 CallStructure callStructure,
11001 A arg) { 12380 A arg) {
11002 return handleConstructorInvoke( 12381 return handleConstructorInvoke(
11003 node, constructor, type, arguments, callStructure, arg); 12382 node, constructor, type, arguments, callStructure, arg);
11004 } 12383 }
11005 } 12384 }
OLDNEW
« no previous file with comments | « pkg/compiler/lib/src/resolution/semantic_visitor.dart ('k') | pkg/compiler/lib/src/resolution/send_structure.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698