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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 1088933004: Use CallStructure instead of Selector in SemanticSendVisitor. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 5 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « pkg/compiler/lib/src/resolution/semantic_visitor.dart ('k') | pkg/compiler/lib/src/resolution/send_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 /// Mixin that implements all `errorX` methods of [SemanticSendVisitor] by 7 /// Mixin that implements all `errorX` methods of [SemanticSendVisitor] by
8 /// delegating to a bulk handler. 8 /// delegating to a bulk handler.
9 /// 9 ///
10 /// Use this mixin to provide a trivial implementation for all `errorX` methods. 10 /// Use this mixin to provide a trivial implementation for all `errorX` methods.
(...skipping 11 matching lines...) Expand all
22 A arg) { 22 A arg) {
23 return bulkHandleError(node, arg); 23 return bulkHandleError(node, arg);
24 } 24 }
25 25
26 @override 26 @override
27 R errorAbstractClassConstructorInvoke( 27 R errorAbstractClassConstructorInvoke(
28 NewExpression node, 28 NewExpression node,
29 ConstructorElement element, 29 ConstructorElement element,
30 InterfaceType type, 30 InterfaceType type,
31 NodeList arguments, 31 NodeList arguments,
32 Selector selector, 32 CallStructure callStructure,
33 A arg) { 33 A arg) {
34 return bulkHandleError(node, arg); 34 return bulkHandleError(node, arg);
35 } 35 }
36 36
37 @override 37 @override
38 R errorClassTypeLiteralCompound( 38 R errorClassTypeLiteralCompound(
39 Send node, 39 Send node,
40 ConstantExpression constant, 40 ConstantExpression constant,
41 AssignmentOperator operator, 41 AssignmentOperator operator,
42 Node rhs, 42 Node rhs,
(...skipping 222 matching lines...) Expand 10 before | Expand all | Expand 10 after
265 FunctionElement setter, 265 FunctionElement setter,
266 A arg) { 266 A arg) {
267 return bulkHandleError(node, arg); 267 return bulkHandleError(node, arg);
268 } 268 }
269 269
270 @override 270 @override
271 R errorStaticSetterInvoke( 271 R errorStaticSetterInvoke(
272 Send node, 272 Send node,
273 FunctionElement setter, 273 FunctionElement setter,
274 NodeList arguments, 274 NodeList arguments,
275 Selector selector, 275 CallStructure callStructure,
276 A arg) { 276 A arg) {
277 return bulkHandleError(node, arg); 277 return bulkHandleError(node, arg);
278 } 278 }
279 279
280 @override 280 @override
281 R errorSuperGetterSet( 281 R errorSuperGetterSet(
282 SendSet node, 282 SendSet node,
283 FunctionElement getter, 283 FunctionElement getter,
284 Node rhs, 284 Node rhs,
285 A arg) { 285 A arg) {
(...skipping 15 matching lines...) Expand all
301 FunctionElement setter, 301 FunctionElement setter,
302 A arg) { 302 A arg) {
303 return bulkHandleError(node, arg); 303 return bulkHandleError(node, arg);
304 } 304 }
305 305
306 @override 306 @override
307 R errorSuperSetterInvoke( 307 R errorSuperSetterInvoke(
308 Send node, 308 Send node,
309 FunctionElement setter, 309 FunctionElement setter,
310 NodeList arguments, 310 NodeList arguments,
311 Selector selector, 311 CallStructure callStructure,
312 A arg) { 312 A arg) {
313 return bulkHandleError(node, arg); 313 return bulkHandleError(node, arg);
314 } 314 }
315 315
316 @override 316 @override
317 R errorTopLevelFunctionSet( 317 R errorTopLevelFunctionSet(
318 Send node, 318 Send node,
319 MethodElement function, 319 MethodElement function,
320 Node rhs, 320 Node rhs,
321 A arg) { 321 A arg) {
(...skipping 15 matching lines...) Expand all
337 FunctionElement setter, 337 FunctionElement setter,
338 A arg) { 338 A arg) {
339 return bulkHandleError(node, arg); 339 return bulkHandleError(node, arg);
340 } 340 }
341 341
342 @override 342 @override
343 R errorTopLevelSetterInvoke( 343 R errorTopLevelSetterInvoke(
344 Send node, 344 Send node,
345 FunctionElement setter, 345 FunctionElement setter,
346 NodeList arguments, 346 NodeList arguments,
347 Selector selector, 347 CallStructure callStructure,
348 A arg) { 348 A arg) {
349 return bulkHandleError(node, arg); 349 return bulkHandleError(node, arg);
350 } 350 }
351 351
352 @override 352 @override
353 R errorTypeVariableTypeLiteralCompound( 353 R errorTypeVariableTypeLiteralCompound(
354 Send node, 354 Send node,
355 TypeVariableElement element, 355 TypeVariableElement element,
356 AssignmentOperator operator, 356 AssignmentOperator operator,
357 Node rhs, 357 Node rhs,
(...skipping 806 matching lines...) Expand 10 before | Expand all | Expand 10 after
1164 1164
1165 R bulkHandleInvoke(Send node, A arg) { 1165 R bulkHandleInvoke(Send node, A arg) {
1166 return bulkHandleNode(node, "Invocation `$node` unhandled.", arg); 1166 return bulkHandleNode(node, "Invocation `$node` unhandled.", arg);
1167 } 1167 }
1168 1168
1169 @override 1169 @override
1170 R visitClassTypeLiteralInvoke( 1170 R visitClassTypeLiteralInvoke(
1171 Send node, 1171 Send node,
1172 ConstantExpression constant, 1172 ConstantExpression constant,
1173 NodeList arguments, 1173 NodeList arguments,
1174 Selector selector, 1174 CallStructure callStructure,
1175 A arg) { 1175 A arg) {
1176 return bulkHandleInvoke(node, arg); 1176 return bulkHandleInvoke(node, arg);
1177 } 1177 }
1178 1178
1179 @override 1179 @override
1180 R visitDynamicPropertyInvoke( 1180 R visitDynamicPropertyInvoke(
1181 Send node, 1181 Send node,
1182 Node receiver, 1182 Node receiver,
1183 NodeList arguments, 1183 NodeList arguments,
1184 Selector selector, 1184 Selector selector,
1185 A arg) { 1185 A arg) {
1186 return bulkHandleInvoke(node, arg); 1186 return bulkHandleInvoke(node, arg);
1187 } 1187 }
1188 1188
1189 @override 1189 @override
1190 R visitDynamicTypeLiteralInvoke( 1190 R visitDynamicTypeLiteralInvoke(
1191 Send node, 1191 Send node,
1192 ConstantExpression constant, 1192 ConstantExpression constant,
1193 NodeList arguments, 1193 NodeList arguments,
1194 Selector selector, 1194 CallStructure callStructure,
1195 A arg) { 1195 A arg) {
1196 return bulkHandleInvoke(node, arg); 1196 return bulkHandleInvoke(node, arg);
1197 } 1197 }
1198 1198
1199 @override 1199 @override
1200 R visitExpressionInvoke( 1200 R visitExpressionInvoke(
1201 Send node, 1201 Send node,
1202 Node expression, 1202 Node expression,
1203 NodeList arguments, 1203 NodeList arguments,
1204 Selector selector, 1204 Selector selector,
1205 A arg) { 1205 A arg) {
1206 return bulkHandleInvoke(node, arg); 1206 return bulkHandleInvoke(node, arg);
1207 } 1207 }
1208 1208
1209 @override 1209 @override
1210 R visitLocalFunctionInvoke( 1210 R visitLocalFunctionInvoke(
1211 Send node, 1211 Send node,
1212 LocalFunctionElement function, 1212 LocalFunctionElement function,
1213 NodeList arguments, 1213 NodeList arguments,
1214 Selector selector, 1214 CallStructure callStructure,
1215 A arg) { 1215 A arg) {
1216 return bulkHandleInvoke(node, arg); 1216 return bulkHandleInvoke(node, arg);
1217 } 1217 }
1218 1218
1219 @override 1219 @override
1220 R visitLocalVariableInvoke( 1220 R visitLocalVariableInvoke(
1221 Send node, 1221 Send node,
1222 LocalVariableElement variable, 1222 LocalVariableElement variable,
1223 NodeList arguments, 1223 NodeList arguments,
1224 Selector selector, 1224 CallStructure callStructure,
1225 A arg) { 1225 A arg) {
1226 return bulkHandleInvoke(node, arg); 1226 return bulkHandleInvoke(node, arg);
1227 } 1227 }
1228 1228
1229 @override 1229 @override
1230 R visitParameterInvoke( 1230 R visitParameterInvoke(
1231 Send node, 1231 Send node,
1232 ParameterElement parameter, 1232 ParameterElement parameter,
1233 NodeList arguments, 1233 NodeList arguments,
1234 Selector selector, 1234 CallStructure callStructure,
1235 A arg) { 1235 A arg) {
1236 return bulkHandleInvoke(node, arg); 1236 return bulkHandleInvoke(node, arg);
1237 } 1237 }
1238 1238
1239 @override 1239 @override
1240 R visitStaticFieldInvoke( 1240 R visitStaticFieldInvoke(
1241 Send node, 1241 Send node,
1242 FieldElement field, 1242 FieldElement field,
1243 NodeList arguments, 1243 NodeList arguments,
1244 Selector selector, 1244 CallStructure callStructure,
1245 A arg) { 1245 A arg) {
1246 return bulkHandleInvoke(node, arg); 1246 return bulkHandleInvoke(node, arg);
1247 } 1247 }
1248 1248
1249 @override 1249 @override
1250 R visitStaticFunctionInvoke( 1250 R visitStaticFunctionInvoke(
1251 Send node, 1251 Send node,
1252 MethodElement function, 1252 MethodElement function,
1253 NodeList arguments, 1253 NodeList arguments,
1254 Selector selector, 1254 CallStructure callStructure,
1255 A arg) { 1255 A arg) {
1256 return bulkHandleInvoke(node, arg); 1256 return bulkHandleInvoke(node, arg);
1257 } 1257 }
1258 1258
1259 @override 1259 @override
1260 R visitStaticGetterInvoke( 1260 R visitStaticGetterInvoke(
1261 Send node, 1261 Send node,
1262 FunctionElement getter, 1262 FunctionElement getter,
1263 NodeList arguments, 1263 NodeList arguments,
1264 Selector selector, 1264 CallStructure callStructure,
1265 A arg) { 1265 A arg) {
1266 return bulkHandleInvoke(node, arg); 1266 return bulkHandleInvoke(node, arg);
1267 } 1267 }
1268 1268
1269 @override 1269 @override
1270 R visitSuperFieldInvoke( 1270 R visitSuperFieldInvoke(
1271 Send node, 1271 Send node,
1272 FieldElement field, 1272 FieldElement field,
1273 NodeList arguments, 1273 NodeList arguments,
1274 Selector selector, 1274 CallStructure callStructure,
1275 A arg) { 1275 A arg) {
1276 return bulkHandleInvoke(node, arg); 1276 return bulkHandleInvoke(node, arg);
1277 } 1277 }
1278 1278
1279 @override 1279 @override
1280 R visitSuperGetterInvoke( 1280 R visitSuperGetterInvoke(
1281 Send node, 1281 Send node,
1282 FunctionElement getter, 1282 FunctionElement getter,
1283 NodeList arguments, 1283 NodeList arguments,
1284 Selector selector, 1284 CallStructure callStructure,
1285 A arg) { 1285 A arg) {
1286 return bulkHandleInvoke(node, arg); 1286 return bulkHandleInvoke(node, arg);
1287 } 1287 }
1288 1288
1289 @override 1289 @override
1290 R visitSuperMethodInvoke( 1290 R visitSuperMethodInvoke(
1291 Send node, 1291 Send node,
1292 MethodElement method, 1292 MethodElement method,
1293 NodeList arguments, 1293 NodeList arguments,
1294 Selector selector, 1294 CallStructure callStructure,
1295 A arg) { 1295 A arg) {
1296 return bulkHandleInvoke(node, arg); 1296 return bulkHandleInvoke(node, arg);
1297 } 1297 }
1298 1298
1299 @override 1299 @override
1300 R visitThisInvoke( 1300 R visitThisInvoke(
1301 Send node, 1301 Send node,
1302 NodeList arguments, 1302 NodeList arguments,
1303 Selector selector, 1303 CallStructure callStructure,
1304 A arg) { 1304 A arg) {
1305 return bulkHandleInvoke(node, arg); 1305 return bulkHandleInvoke(node, arg);
1306 } 1306 }
1307 1307
1308 @override 1308 @override
1309 R visitThisPropertyInvoke( 1309 R visitThisPropertyInvoke(
1310 Send node, 1310 Send node,
1311 NodeList arguments, 1311 NodeList arguments,
1312 Selector selector, 1312 Selector selector,
1313 A arg) { 1313 A arg) {
1314 return bulkHandleInvoke(node, arg); 1314 return bulkHandleInvoke(node, arg);
1315 } 1315 }
1316 1316
1317 @override 1317 @override
1318 R visitTopLevelFieldInvoke( 1318 R visitTopLevelFieldInvoke(
1319 Send node, 1319 Send node,
1320 FieldElement field, 1320 FieldElement field,
1321 NodeList arguments, 1321 NodeList arguments,
1322 Selector selector, 1322 CallStructure callStructure,
1323 A arg) { 1323 A arg) {
1324 return bulkHandleInvoke(node, arg); 1324 return bulkHandleInvoke(node, arg);
1325 } 1325 }
1326 1326
1327 @override 1327 @override
1328 R visitTopLevelFunctionInvoke( 1328 R visitTopLevelFunctionInvoke(
1329 Send node, 1329 Send node,
1330 MethodElement function, 1330 MethodElement function,
1331 NodeList arguments, 1331 NodeList arguments,
1332 Selector selector, 1332 CallStructure callStructure,
1333 A arg) { 1333 A arg) {
1334 return bulkHandleInvoke(node, arg); 1334 return bulkHandleInvoke(node, arg);
1335 } 1335 }
1336 1336
1337 @override 1337 @override
1338 R visitTopLevelGetterInvoke( 1338 R visitTopLevelGetterInvoke(
1339 Send node, 1339 Send node,
1340 FunctionElement getter, 1340 FunctionElement getter,
1341 NodeList arguments, 1341 NodeList arguments,
1342 Selector selector, 1342 CallStructure callStructure,
1343 A arg) { 1343 A arg) {
1344 return bulkHandleInvoke(node, arg); 1344 return bulkHandleInvoke(node, arg);
1345 } 1345 }
1346 1346
1347 @override 1347 @override
1348 R visitTypeVariableTypeLiteralInvoke( 1348 R visitTypeVariableTypeLiteralInvoke(
1349 Send node, 1349 Send node,
1350 TypeVariableElement element, 1350 TypeVariableElement element,
1351 NodeList arguments, 1351 NodeList arguments,
1352 Selector selector, 1352 CallStructure callStructure,
1353 A arg) { 1353 A arg) {
1354 return bulkHandleInvoke(node, arg); 1354 return bulkHandleInvoke(node, arg);
1355 } 1355 }
1356 1356
1357 @override 1357 @override
1358 R visitTypedefTypeLiteralInvoke( 1358 R visitTypedefTypeLiteralInvoke(
1359 Send node, 1359 Send node,
1360 ConstantExpression constant, 1360 ConstantExpression constant,
1361 NodeList arguments, 1361 NodeList arguments,
1362 Selector selector, 1362 CallStructure callStructure,
1363 A arg) { 1363 A arg) {
1364 return bulkHandleInvoke(node, arg); 1364 return bulkHandleInvoke(node, arg);
1365 } 1365 }
1366 1366
1367 @override 1367 @override
1368 R visitConstantInvoke( 1368 R visitConstantInvoke(
1369 Send node, 1369 Send node,
1370 ConstantExpression constant, 1370 ConstantExpression constant,
1371 NodeList arguments, 1371 NodeList arguments,
1372 Selector selector, 1372 CallStructure callStructure,
1373 A arg) { 1373 A arg) {
1374 return bulkHandleInvoke(node, arg); 1374 return bulkHandleInvoke(node, arg);
1375 } 1375 }
1376 } 1376 }
1377 1377
1378 /// Mixin that implements all `visitXGet` methods of [SemanticSendVisitor] by 1378 /// Mixin that implements all `visitXGet` methods of [SemanticSendVisitor] by
1379 /// delegating to a bulk handler. 1379 /// delegating to a bulk handler.
1380 /// 1380 ///
1381 /// Use this mixin to provide a trivial implementation for all `visitXGet` 1381 /// Use this mixin to provide a trivial implementation for all `visitXGet`
1382 /// methods. 1382 /// methods.
(...skipping 587 matching lines...) Expand 10 before | Expand all | Expand 10 after
1970 FieldElement field, 1970 FieldElement field,
1971 A arg) { 1971 A arg) {
1972 return bulkHandleSuper(node, arg); 1972 return bulkHandleSuper(node, arg);
1973 } 1973 }
1974 1974
1975 @override 1975 @override
1976 R visitSuperFieldInvoke( 1976 R visitSuperFieldInvoke(
1977 Send node, 1977 Send node,
1978 FieldElement field, 1978 FieldElement field,
1979 NodeList arguments, 1979 NodeList arguments,
1980 Selector selector, 1980 CallStructure callStructure,
1981 A arg) { 1981 A arg) {
1982 return bulkHandleSuper(node, arg); 1982 return bulkHandleSuper(node, arg);
1983 } 1983 }
1984 1984
1985 @override 1985 @override
1986 R visitSuperFieldPostfix( 1986 R visitSuperFieldPostfix(
1987 Send node, 1987 Send node,
1988 FieldElement field, 1988 FieldElement field,
1989 IncDecOperator operator, 1989 IncDecOperator operator,
1990 A arg) { 1990 A arg) {
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after
2077 FunctionElement getter, 2077 FunctionElement getter,
2078 A arg) { 2078 A arg) {
2079 return bulkHandleSuper(node, arg); 2079 return bulkHandleSuper(node, arg);
2080 } 2080 }
2081 2081
2082 @override 2082 @override
2083 R visitSuperGetterInvoke( 2083 R visitSuperGetterInvoke(
2084 Send node, 2084 Send node,
2085 FunctionElement getter, 2085 FunctionElement getter,
2086 NodeList arguments, 2086 NodeList arguments,
2087 Selector selector, 2087 CallStructure callStructure,
2088 A arg) { 2088 A arg) {
2089 return bulkHandleSuper(node, arg); 2089 return bulkHandleSuper(node, arg);
2090 } 2090 }
2091 2091
2092 @override 2092 @override
2093 R visitSuperGetterSetterCompound( 2093 R visitSuperGetterSetterCompound(
2094 Send node, 2094 Send node,
2095 FunctionElement getter, 2095 FunctionElement getter,
2096 FunctionElement setter, 2096 FunctionElement setter,
2097 AssignmentOperator operator, 2097 AssignmentOperator operator,
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
2136 MethodElement method, 2136 MethodElement method,
2137 A arg) { 2137 A arg) {
2138 return bulkHandleSuper(node, arg); 2138 return bulkHandleSuper(node, arg);
2139 } 2139 }
2140 2140
2141 @override 2141 @override
2142 R visitSuperMethodInvoke( 2142 R visitSuperMethodInvoke(
2143 Send node, 2143 Send node,
2144 MethodElement method, 2144 MethodElement method,
2145 NodeList arguments, 2145 NodeList arguments,
2146 Selector selector, 2146 CallStructure callStructure,
2147 A arg) { 2147 A arg) {
2148 return bulkHandleSuper(node, arg); 2148 return bulkHandleSuper(node, arg);
2149 } 2149 }
2150 2150
2151 @override 2151 @override
2152 R visitSuperMethodSetterCompound( 2152 R visitSuperMethodSetterCompound(
2153 Send node, 2153 Send node,
2154 FunctionElement method, 2154 FunctionElement method,
2155 FunctionElement setter, 2155 FunctionElement setter,
2156 AssignmentOperator operator, 2156 AssignmentOperator operator,
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after
2221 ConstructedConstantExpression constant, 2221 ConstructedConstantExpression constant,
2222 A arg) { 2222 A arg) {
2223 return bulkHandleNew(node, arg); 2223 return bulkHandleNew(node, arg);
2224 } 2224 }
2225 2225
2226 R visitGenerativeConstructorInvoke( 2226 R visitGenerativeConstructorInvoke(
2227 NewExpression node, 2227 NewExpression node,
2228 ConstructorElement constructor, 2228 ConstructorElement constructor,
2229 InterfaceType type, 2229 InterfaceType type,
2230 NodeList arguments, 2230 NodeList arguments,
2231 Selector selector, 2231 CallStructure callStructure,
2232 A arg) { 2232 A arg) {
2233 return bulkHandleNew(node, arg); 2233 return bulkHandleNew(node, arg);
2234 } 2234 }
2235 2235
2236 R visitRedirectingGenerativeConstructorInvoke( 2236 R visitRedirectingGenerativeConstructorInvoke(
2237 NewExpression node, 2237 NewExpression node,
2238 ConstructorElement constructor, 2238 ConstructorElement constructor,
2239 InterfaceType type, 2239 InterfaceType type,
2240 NodeList arguments, 2240 NodeList arguments,
2241 Selector selector, 2241 CallStructure callStructure,
2242 A arg) { 2242 A arg) {
2243 return bulkHandleNew(node, arg); 2243 return bulkHandleNew(node, arg);
2244 } 2244 }
2245 2245
2246 R visitFactoryConstructorInvoke( 2246 R visitFactoryConstructorInvoke(
2247 NewExpression node, 2247 NewExpression node,
2248 ConstructorElement constructor, 2248 ConstructorElement constructor,
2249 InterfaceType type, 2249 InterfaceType type,
2250 NodeList arguments, 2250 NodeList arguments,
2251 Selector selector, 2251 CallStructure callStructure,
2252 A arg) { 2252 A arg) {
2253 return bulkHandleNew(node, arg); 2253 return bulkHandleNew(node, arg);
2254 } 2254 }
2255 2255
2256 R visitRedirectingFactoryConstructorInvoke( 2256 R visitRedirectingFactoryConstructorInvoke(
2257 NewExpression node, 2257 NewExpression node,
2258 ConstructorElement constructor, 2258 ConstructorElement constructor,
2259 InterfaceType type, 2259 InterfaceType type,
2260 ConstructorElement effectiveTarget, 2260 ConstructorElement effectiveTarget,
2261 InterfaceType effectiveTargetType, 2261 InterfaceType effectiveTargetType,
2262 NodeList arguments, 2262 NodeList arguments,
2263 Selector selector, 2263 CallStructure callStructure,
2264 A arg) { 2264 A arg) {
2265 return bulkHandleNew(node, arg); 2265 return bulkHandleNew(node, arg);
2266 } 2266 }
2267 } 2267 }
2268 2268
2269 /// Visitor that implements [SemanticSendVisitor] by the use of `BulkX` mixins. 2269 /// Visitor that implements [SemanticSendVisitor] by the use of `BulkX` mixins.
2270 /// 2270 ///
2271 /// This class is useful in itself, but shows how to use the `BulkX` mixins and 2271 /// This class is useful in itself, but shows how to use the `BulkX` mixins and
2272 /// tests that the union of the `BulkX` mixins implement all `visit` and `error` 2272 /// tests that the union of the `BulkX` mixins implement all `visit` and `error`
2273 /// methods of [SemanticSendVisitor]. 2273 /// methods of [SemanticSendVisitor].
(...skipping 702 matching lines...) Expand 10 before | Expand all | Expand 10 after
2976 FunctionElement setter, 2976 FunctionElement setter,
2977 A arg) { 2977 A arg) {
2978 return null; 2978 return null;
2979 } 2979 }
2980 2980
2981 @override 2981 @override
2982 R errorStaticSetterInvoke( 2982 R errorStaticSetterInvoke(
2983 Send node, 2983 Send node,
2984 FunctionElement setter, 2984 FunctionElement setter,
2985 NodeList arguments, 2985 NodeList arguments,
2986 Selector selector, 2986 CallStructure callStructure,
2987 A arg) { 2987 A arg) {
2988 apply(arguments, arg); 2988 apply(arguments, arg);
2989 return null; 2989 return null;
2990 } 2990 }
2991 2991
2992 @override 2992 @override
2993 R errorSuperGetterSet( 2993 R errorSuperGetterSet(
2994 SendSet node, 2994 SendSet node,
2995 FunctionElement getter, 2995 FunctionElement getter,
2996 Node rhs, 2996 Node rhs,
(...skipping 18 matching lines...) Expand all
3015 FunctionElement setter, 3015 FunctionElement setter,
3016 A arg) { 3016 A arg) {
3017 return null; 3017 return null;
3018 } 3018 }
3019 3019
3020 @override 3020 @override
3021 R errorSuperSetterInvoke( 3021 R errorSuperSetterInvoke(
3022 Send node, 3022 Send node,
3023 FunctionElement setter, 3023 FunctionElement setter,
3024 NodeList arguments, 3024 NodeList arguments,
3025 Selector selector, 3025 CallStructure callStructure,
3026 A arg) { 3026 A arg) {
3027 apply(arguments, arg); 3027 apply(arguments, arg);
3028 return null; 3028 return null;
3029 } 3029 }
3030 3030
3031 @override 3031 @override
3032 R errorTopLevelFunctionSet( 3032 R errorTopLevelFunctionSet(
3033 Send node, 3033 Send node,
3034 MethodElement function, 3034 MethodElement function,
3035 Node rhs, 3035 Node rhs,
(...skipping 18 matching lines...) Expand all
3054 FunctionElement setter, 3054 FunctionElement setter,
3055 A arg) { 3055 A arg) {
3056 return null; 3056 return null;
3057 } 3057 }
3058 3058
3059 @override 3059 @override
3060 R errorTopLevelSetterInvoke( 3060 R errorTopLevelSetterInvoke(
3061 Send node, 3061 Send node,
3062 FunctionElement setter, 3062 FunctionElement setter,
3063 NodeList arguments, 3063 NodeList arguments,
3064 Selector selector, 3064 CallStructure callStructure,
3065 A arg) { 3065 A arg) {
3066 apply(arguments, arg); 3066 apply(arguments, arg);
3067 return null; 3067 return null;
3068 } 3068 }
3069 3069
3070 @override 3070 @override
3071 R errorTypeVariableTypeLiteralSet( 3071 R errorTypeVariableTypeLiteralSet(
3072 SendSet node, 3072 SendSet node,
3073 TypeVariableElement element, 3073 TypeVariableElement element,
3074 Node rhs, 3074 Node rhs,
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after
3145 ConstantExpression constant, 3145 ConstantExpression constant,
3146 A arg) { 3146 A arg) {
3147 return null; 3147 return null;
3148 } 3148 }
3149 3149
3150 @override 3150 @override
3151 R visitClassTypeLiteralInvoke( 3151 R visitClassTypeLiteralInvoke(
3152 Send node, 3152 Send node,
3153 ConstantExpression constant, 3153 ConstantExpression constant,
3154 NodeList arguments, 3154 NodeList arguments,
3155 Selector selector, 3155 CallStructure callStructure,
3156 A arg) { 3156 A arg) {
3157 apply(arguments, arg); 3157 apply(arguments, arg);
3158 return null; 3158 return null;
3159 } 3159 }
3160 3160
3161 @override 3161 @override
3162 R errorClassTypeLiteralPostfix( 3162 R errorClassTypeLiteralPostfix(
3163 Send node, 3163 Send node,
3164 ConstantExpression constant, 3164 ConstantExpression constant,
3165 IncDecOperator operator, 3165 IncDecOperator operator,
(...skipping 30 matching lines...) Expand all
3196 ConstantExpression constant, 3196 ConstantExpression constant,
3197 A arg) { 3197 A arg) {
3198 return null; 3198 return null;
3199 } 3199 }
3200 3200
3201 @override 3201 @override
3202 R visitConstantInvoke( 3202 R visitConstantInvoke(
3203 Send node, 3203 Send node,
3204 ConstantExpression constant, 3204 ConstantExpression constant,
3205 NodeList arguments, 3205 NodeList arguments,
3206 Selector selector, 3206 CallStructure callStructure,
3207 A arg) { 3207 A arg) {
3208 apply(arguments, arg); 3208 apply(arguments, arg);
3209 return null; 3209 return null;
3210 } 3210 }
3211 3211
3212 @override 3212 @override
3213 R visitDynamicPropertyCompound( 3213 R visitDynamicPropertyCompound(
3214 Send node, 3214 Send node,
3215 Node receiver, 3215 Node receiver,
3216 AssignmentOperator operator, 3216 AssignmentOperator operator,
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after
3297 ConstantExpression constant, 3297 ConstantExpression constant,
3298 A arg) { 3298 A arg) {
3299 return null; 3299 return null;
3300 } 3300 }
3301 3301
3302 @override 3302 @override
3303 R visitDynamicTypeLiteralInvoke( 3303 R visitDynamicTypeLiteralInvoke(
3304 Send node, 3304 Send node,
3305 ConstantExpression constant, 3305 ConstantExpression constant,
3306 NodeList arguments, 3306 NodeList arguments,
3307 Selector selector, 3307 CallStructure callStructure,
3308 A arg) { 3308 A arg) {
3309 apply(arguments, arg); 3309 apply(arguments, arg);
3310 return null; 3310 return null;
3311 } 3311 }
3312 3312
3313 @override 3313 @override
3314 R errorDynamicTypeLiteralPostfix( 3314 R errorDynamicTypeLiteralPostfix(
3315 Send node, 3315 Send node,
3316 ConstantExpression constant, 3316 ConstantExpression constant,
3317 IncDecOperator operator, 3317 IncDecOperator operator,
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after
3401 LocalFunctionElement function, 3401 LocalFunctionElement function,
3402 A arg) { 3402 A arg) {
3403 return null; 3403 return null;
3404 } 3404 }
3405 3405
3406 @override 3406 @override
3407 R visitLocalFunctionInvoke( 3407 R visitLocalFunctionInvoke(
3408 Send node, 3408 Send node,
3409 LocalFunctionElement function, 3409 LocalFunctionElement function,
3410 NodeList arguments, 3410 NodeList arguments,
3411 Selector selector, 3411 CallStructure callStructure,
3412 A arg) { 3412 A arg) {
3413 apply(arguments, arg); 3413 apply(arguments, arg);
3414 return null; 3414 return null;
3415 } 3415 }
3416 3416
3417 @override 3417 @override
3418 R visitLocalVariableCompound( 3418 R visitLocalVariableCompound(
3419 Send node, 3419 Send node,
3420 LocalVariableElement variable, 3420 LocalVariableElement variable,
3421 AssignmentOperator operator, 3421 AssignmentOperator operator,
3422 Node rhs, 3422 Node rhs,
3423 A arg) { 3423 A arg) {
3424 apply(rhs, arg); 3424 apply(rhs, arg);
3425 return null; 3425 return null;
3426 } 3426 }
3427 3427
3428 @override 3428 @override
3429 R visitLocalVariableGet( 3429 R visitLocalVariableGet(
3430 Send node, 3430 Send node,
3431 LocalVariableElement variable, 3431 LocalVariableElement variable,
3432 A arg) { 3432 A arg) {
3433 return null; 3433 return null;
3434 } 3434 }
3435 3435
3436 @override 3436 @override
3437 R visitLocalVariableInvoke( 3437 R visitLocalVariableInvoke(
3438 Send node, 3438 Send node,
3439 LocalVariableElement variable, 3439 LocalVariableElement variable,
3440 NodeList arguments, 3440 NodeList arguments,
3441 Selector selector, 3441 CallStructure callStructure,
3442 A arg) { 3442 A arg) {
3443 apply(arguments, arg); 3443 apply(arguments, arg);
3444 return null; 3444 return null;
3445 } 3445 }
3446 3446
3447 @override 3447 @override
3448 R visitLocalVariablePostfix( 3448 R visitLocalVariablePostfix(
3449 Send node, 3449 Send node,
3450 LocalVariableElement variable, 3450 LocalVariableElement variable,
3451 IncDecOperator operator, 3451 IncDecOperator operator,
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after
3531 ParameterElement parameter, 3531 ParameterElement parameter,
3532 A arg) { 3532 A arg) {
3533 return null; 3533 return null;
3534 } 3534 }
3535 3535
3536 @override 3536 @override
3537 R visitParameterInvoke( 3537 R visitParameterInvoke(
3538 Send node, 3538 Send node,
3539 ParameterElement parameter, 3539 ParameterElement parameter,
3540 NodeList arguments, 3540 NodeList arguments,
3541 Selector selector, 3541 CallStructure callStructure,
3542 A arg) { 3542 A arg) {
3543 apply(arguments, arg); 3543 apply(arguments, arg);
3544 return null; 3544 return null;
3545 } 3545 }
3546 3546
3547 @override 3547 @override
3548 R visitParameterPostfix( 3548 R visitParameterPostfix(
3549 Send node, 3549 Send node,
3550 ParameterElement parameter, 3550 ParameterElement parameter,
3551 IncDecOperator operator, 3551 IncDecOperator operator,
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
3589 FieldElement field, 3589 FieldElement field,
3590 A arg) { 3590 A arg) {
3591 return null; 3591 return null;
3592 } 3592 }
3593 3593
3594 @override 3594 @override
3595 R visitStaticFieldInvoke( 3595 R visitStaticFieldInvoke(
3596 Send node, 3596 Send node,
3597 FieldElement field, 3597 FieldElement field,
3598 NodeList arguments, 3598 NodeList arguments,
3599 Selector selector, 3599 CallStructure callStructure,
3600 A arg) { 3600 A arg) {
3601 apply(arguments, arg); 3601 apply(arguments, arg);
3602 return null; 3602 return null;
3603 } 3603 }
3604 3604
3605 @override 3605 @override
3606 R visitStaticFieldPostfix( 3606 R visitStaticFieldPostfix(
3607 Send node, 3607 Send node,
3608 FieldElement field, 3608 FieldElement field,
3609 IncDecOperator operator, 3609 IncDecOperator operator,
(...skipping 26 matching lines...) Expand all
3636 MethodElement function, 3636 MethodElement function,
3637 A arg) { 3637 A arg) {
3638 return null; 3638 return null;
3639 } 3639 }
3640 3640
3641 @override 3641 @override
3642 R visitStaticFunctionInvoke( 3642 R visitStaticFunctionInvoke(
3643 Send node, 3643 Send node,
3644 MethodElement function, 3644 MethodElement function,
3645 NodeList arguments, 3645 NodeList arguments,
3646 Selector selector, 3646 CallStructure callStructure,
3647 A arg) { 3647 A arg) {
3648 apply(arguments, arg); 3648 apply(arguments, arg);
3649 return null; 3649 return null;
3650 } 3650 }
3651 3651
3652 @override 3652 @override
3653 R visitStaticGetterGet( 3653 R visitStaticGetterGet(
3654 Send node, 3654 Send node,
3655 FunctionElement getter, 3655 FunctionElement getter,
3656 A arg) { 3656 A arg) {
3657 return null; 3657 return null;
3658 } 3658 }
3659 3659
3660 @override 3660 @override
3661 R visitStaticGetterInvoke( 3661 R visitStaticGetterInvoke(
3662 Send node, 3662 Send node,
3663 FunctionElement getter, 3663 FunctionElement getter,
3664 NodeList arguments, 3664 NodeList arguments,
3665 Selector selector, 3665 CallStructure callStructure,
3666 A arg) { 3666 A arg) {
3667 apply(arguments, arg); 3667 apply(arguments, arg);
3668 return null; 3668 return null;
3669 } 3669 }
3670 3670
3671 @override 3671 @override
3672 R visitStaticGetterSetterCompound( 3672 R visitStaticGetterSetterCompound(
3673 Send node, 3673 Send node,
3674 FunctionElement getter, 3674 FunctionElement getter,
3675 FunctionElement setter, 3675 FunctionElement setter,
(...skipping 137 matching lines...) Expand 10 before | Expand all | Expand 10 after
3813 FieldElement field, 3813 FieldElement field,
3814 A arg) { 3814 A arg) {
3815 return null; 3815 return null;
3816 } 3816 }
3817 3817
3818 @override 3818 @override
3819 R visitSuperFieldInvoke( 3819 R visitSuperFieldInvoke(
3820 Send node, 3820 Send node,
3821 FieldElement field, 3821 FieldElement field,
3822 NodeList arguments, 3822 NodeList arguments,
3823 Selector selector, 3823 CallStructure callStructure,
3824 A arg) { 3824 A arg) {
3825 apply(arguments, arg); 3825 apply(arguments, arg);
3826 return null; 3826 return null;
3827 } 3827 }
3828 3828
3829 @override 3829 @override
3830 R visitSuperFieldPostfix( 3830 R visitSuperFieldPostfix(
3831 Send node, 3831 Send node,
3832 FieldElement field, 3832 FieldElement field,
3833 IncDecOperator operator, 3833 IncDecOperator operator,
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after
3924 FunctionElement getter, 3924 FunctionElement getter,
3925 A arg) { 3925 A arg) {
3926 return null; 3926 return null;
3927 } 3927 }
3928 3928
3929 @override 3929 @override
3930 R visitSuperGetterInvoke( 3930 R visitSuperGetterInvoke(
3931 Send node, 3931 Send node,
3932 FunctionElement getter, 3932 FunctionElement getter,
3933 NodeList arguments, 3933 NodeList arguments,
3934 Selector selector, 3934 CallStructure callStructure,
3935 A arg) { 3935 A arg) {
3936 apply(arguments, arg); 3936 apply(arguments, arg);
3937 return null; 3937 return null;
3938 } 3938 }
3939 3939
3940 @override 3940 @override
3941 R visitSuperGetterSetterCompound( 3941 R visitSuperGetterSetterCompound(
3942 Send node, 3942 Send node,
3943 FunctionElement getter, 3943 FunctionElement getter,
3944 FunctionElement setter, 3944 FunctionElement setter,
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after
3997 MethodElement method, 3997 MethodElement method,
3998 A arg) { 3998 A arg) {
3999 return null; 3999 return null;
4000 } 4000 }
4001 4001
4002 @override 4002 @override
4003 R visitSuperMethodInvoke( 4003 R visitSuperMethodInvoke(
4004 Send node, 4004 Send node,
4005 MethodElement method, 4005 MethodElement method,
4006 NodeList arguments, 4006 NodeList arguments,
4007 Selector selector, 4007 CallStructure callStructure,
4008 A arg) { 4008 A arg) {
4009 apply(arguments, arg); 4009 apply(arguments, arg);
4010 return null; 4010 return null;
4011 } 4011 }
4012 4012
4013 @override 4013 @override
4014 R visitSuperMethodSetterCompound( 4014 R visitSuperMethodSetterCompound(
4015 Send node, 4015 Send node,
4016 FunctionElement method, 4016 FunctionElement method,
4017 FunctionElement setter, 4017 FunctionElement setter,
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after
4073 4073
4074 @override 4074 @override
4075 R visitThisGet(Identifier node, A arg) { 4075 R visitThisGet(Identifier node, A arg) {
4076 return null; 4076 return null;
4077 } 4077 }
4078 4078
4079 @override 4079 @override
4080 R visitThisInvoke( 4080 R visitThisInvoke(
4081 Send node, 4081 Send node,
4082 NodeList arguments, 4082 NodeList arguments,
4083 Selector selector, 4083 CallStructure callStructure,
4084 A arg) { 4084 A arg) {
4085 apply(arguments, arg); 4085 apply(arguments, arg);
4086 return null; 4086 return null;
4087 } 4087 }
4088 4088
4089 @override 4089 @override
4090 R visitThisPropertyCompound( 4090 R visitThisPropertyCompound(
4091 Send node, 4091 Send node,
4092 AssignmentOperator operator, 4092 AssignmentOperator operator,
4093 Node rhs, 4093 Node rhs,
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after
4163 FieldElement field, 4163 FieldElement field,
4164 A arg) { 4164 A arg) {
4165 return null; 4165 return null;
4166 } 4166 }
4167 4167
4168 @override 4168 @override
4169 R visitTopLevelFieldInvoke( 4169 R visitTopLevelFieldInvoke(
4170 Send node, 4170 Send node,
4171 FieldElement field, 4171 FieldElement field,
4172 NodeList arguments, 4172 NodeList arguments,
4173 Selector selector, 4173 CallStructure callStructure,
4174 A arg) { 4174 A arg) {
4175 apply(arguments, arg); 4175 apply(arguments, arg);
4176 return null; 4176 return null;
4177 } 4177 }
4178 4178
4179 @override 4179 @override
4180 R visitTopLevelFieldPostfix( 4180 R visitTopLevelFieldPostfix(
4181 Send node, 4181 Send node,
4182 FieldElement field, 4182 FieldElement field,
4183 IncDecOperator operator, 4183 IncDecOperator operator,
(...skipping 26 matching lines...) Expand all
4210 MethodElement function, 4210 MethodElement function,
4211 A arg) { 4211 A arg) {
4212 return null; 4212 return null;
4213 } 4213 }
4214 4214
4215 @override 4215 @override
4216 R visitTopLevelFunctionInvoke( 4216 R visitTopLevelFunctionInvoke(
4217 Send node, 4217 Send node,
4218 MethodElement function, 4218 MethodElement function,
4219 NodeList arguments, 4219 NodeList arguments,
4220 Selector selector, 4220 CallStructure callStructure,
4221 A arg) { 4221 A arg) {
4222 apply(arguments, arg); 4222 apply(arguments, arg);
4223 return null; 4223 return null;
4224 } 4224 }
4225 4225
4226 @override 4226 @override
4227 R visitTopLevelGetterGet( 4227 R visitTopLevelGetterGet(
4228 Send node, 4228 Send node,
4229 FunctionElement getter, 4229 FunctionElement getter,
4230 A arg) { 4230 A arg) {
4231 return null; 4231 return null;
4232 } 4232 }
4233 4233
4234 @override 4234 @override
4235 R visitTopLevelGetterInvoke( 4235 R visitTopLevelGetterInvoke(
4236 Send node, 4236 Send node,
4237 FunctionElement getter, 4237 FunctionElement getter,
4238 NodeList arguments, 4238 NodeList arguments,
4239 Selector selector, 4239 CallStructure callStructure,
4240 A arg) { 4240 A arg) {
4241 apply(arguments, arg); 4241 apply(arguments, arg);
4242 return null; 4242 return null;
4243 } 4243 }
4244 4244
4245 @override 4245 @override
4246 R visitTopLevelGetterSetterCompound( 4246 R visitTopLevelGetterSetterCompound(
4247 Send node, 4247 Send node,
4248 FunctionElement getter, 4248 FunctionElement getter,
4249 FunctionElement setter, 4249 FunctionElement setter,
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after
4333 TypeVariableElement element, 4333 TypeVariableElement element,
4334 A arg) { 4334 A arg) {
4335 return null; 4335 return null;
4336 } 4336 }
4337 4337
4338 @override 4338 @override
4339 R visitTypeVariableTypeLiteralInvoke( 4339 R visitTypeVariableTypeLiteralInvoke(
4340 Send node, 4340 Send node,
4341 TypeVariableElement element, 4341 TypeVariableElement element,
4342 NodeList arguments, 4342 NodeList arguments,
4343 Selector selector, 4343 CallStructure callStructure,
4344 A arg) { 4344 A arg) {
4345 apply(arguments, arg); 4345 apply(arguments, arg);
4346 return null; 4346 return null;
4347 } 4347 }
4348 4348
4349 @override 4349 @override
4350 R errorTypeVariableTypeLiteralPostfix( 4350 R errorTypeVariableTypeLiteralPostfix(
4351 Send node, 4351 Send node,
4352 TypeVariableElement element, 4352 TypeVariableElement element,
4353 IncDecOperator operator, 4353 IncDecOperator operator,
(...skipping 27 matching lines...) Expand all
4381 ConstantExpression constant, 4381 ConstantExpression constant,
4382 A arg) { 4382 A arg) {
4383 return null; 4383 return null;
4384 } 4384 }
4385 4385
4386 @override 4386 @override
4387 R visitTypedefTypeLiteralInvoke( 4387 R visitTypedefTypeLiteralInvoke(
4388 Send node, 4388 Send node,
4389 ConstantExpression constant, 4389 ConstantExpression constant,
4390 NodeList arguments, 4390 NodeList arguments,
4391 Selector selector, 4391 CallStructure callStructure,
4392 A arg) { 4392 A arg) {
4393 apply(arguments, arg); 4393 apply(arguments, arg);
4394 return null; 4394 return null;
4395 } 4395 }
4396 4396
4397 @override 4397 @override
4398 R errorTypedefTypeLiteralPostfix( 4398 R errorTypedefTypeLiteralPostfix(
4399 Send node, 4399 Send node,
4400 ConstantExpression constant, 4400 ConstantExpression constant,
4401 IncDecOperator operator, 4401 IncDecOperator operator,
(...skipping 245 matching lines...) Expand 10 before | Expand all | Expand 10 after
4647 apply(arguments, arg); 4647 apply(arguments, arg);
4648 return null; 4648 return null;
4649 } 4649 }
4650 4650
4651 @override 4651 @override
4652 R visitFactoryConstructorInvoke( 4652 R visitFactoryConstructorInvoke(
4653 NewExpression node, 4653 NewExpression node,
4654 ConstructorElement constructor, 4654 ConstructorElement constructor,
4655 InterfaceType type, 4655 InterfaceType type,
4656 NodeList arguments, 4656 NodeList arguments,
4657 Selector selector, 4657 CallStructure callStructure,
4658 A arg) { 4658 A arg) {
4659 apply(arguments, arg); 4659 apply(arguments, arg);
4660 return null; 4660 return null;
4661 } 4661 }
4662 4662
4663 @override 4663 @override
4664 R visitGenerativeConstructorInvoke( 4664 R visitGenerativeConstructorInvoke(
4665 NewExpression node, 4665 NewExpression node,
4666 ConstructorElement constructor, 4666 ConstructorElement constructor,
4667 InterfaceType type, 4667 InterfaceType type,
4668 NodeList arguments, 4668 NodeList arguments,
4669 Selector selector, 4669 CallStructure callStructure,
4670 A arg) { 4670 A arg) {
4671 apply(arguments, arg); 4671 apply(arguments, arg);
4672 return null; 4672 return null;
4673 } 4673 }
4674 4674
4675 @override 4675 @override
4676 R visitRedirectingFactoryConstructorInvoke( 4676 R visitRedirectingFactoryConstructorInvoke(
4677 NewExpression node, 4677 NewExpression node,
4678 ConstructorElement constructor, 4678 ConstructorElement constructor,
4679 InterfaceType type, 4679 InterfaceType type,
4680 ConstructorElement effectiveTarget, 4680 ConstructorElement effectiveTarget,
4681 InterfaceType effectiveTargetType, 4681 InterfaceType effectiveTargetType,
4682 NodeList arguments, 4682 NodeList arguments,
4683 Selector selector, 4683 CallStructure callStructure,
4684 A arg) { 4684 A arg) {
4685 apply(arguments, arg); 4685 apply(arguments, arg);
4686 return null; 4686 return null;
4687 } 4687 }
4688 4688
4689 @override 4689 @override
4690 R visitRedirectingGenerativeConstructorInvoke( 4690 R visitRedirectingGenerativeConstructorInvoke(
4691 NewExpression node, 4691 NewExpression node,
4692 ConstructorElement constructor, 4692 ConstructorElement constructor,
4693 InterfaceType type, 4693 InterfaceType type,
4694 NodeList arguments, 4694 NodeList arguments,
4695 Selector selector, 4695 CallStructure callStructure,
4696 A arg) { 4696 A arg) {
4697 apply(arguments, arg); 4697 apply(arguments, arg);
4698 return null; 4698 return null;
4699 } 4699 }
4700 4700
4701 @override 4701 @override
4702 R errorAbstractClassConstructorInvoke( 4702 R errorAbstractClassConstructorInvoke(
4703 NewExpression node, 4703 NewExpression node,
4704 ConstructorElement element, 4704 ConstructorElement element,
4705 InterfaceType type, 4705 InterfaceType type,
4706 NodeList arguments, 4706 NodeList arguments,
4707 Selector selector, 4707 CallStructure callStructure,
4708 A arg) { 4708 A arg) {
4709 apply(arguments, arg); 4709 apply(arguments, arg);
4710 return null; 4710 return null;
4711 } 4711 }
4712 4712
4713 @override 4713 @override
4714 R errorUnresolvedRedirectingFactoryConstructorInvoke( 4714 R errorUnresolvedRedirectingFactoryConstructorInvoke(
4715 NewExpression node, 4715 NewExpression node,
4716 ConstructorElement constructor, 4716 ConstructorElement constructor,
4717 InterfaceType type, 4717 InterfaceType type,
(...skipping 430 matching lines...) Expand 10 before | Expand all | Expand 10 after
5148 R visitTopLevelSetterDeclaration( 5148 R visitTopLevelSetterDeclaration(
5149 FunctionExpression node, 5149 FunctionExpression node,
5150 MethodElement setter, 5150 MethodElement setter,
5151 NodeList parameters, 5151 NodeList parameters,
5152 Node body, 5152 Node body,
5153 A arg) { 5153 A arg) {
5154 applyParameters(parameters, arg); 5154 applyParameters(parameters, arg);
5155 apply(body, arg); 5155 apply(body, arg);
5156 return null; 5156 return null;
5157 } 5157 }
5158
Johnni Winther 2015/04/14 16:44:20 These are (already) in TraversalSendMixin.
5159 @override
5160 R visitConstConstructorInvoke(
5161 NewExpression node,
5162 ConstructedConstantExpression constant,
5163 A arg) {
5164 return null;
5165 }
5166
5167 @override
5168 R errorUnresolvedClassConstructorInvoke(
5169 NewExpression node,
5170 Element constructor,
5171 MalformedType type,
5172 NodeList arguments,
5173 Selector selector,
5174 A arg) {
5175 apply(arguments, arg);
5176 return null;
5177 }
5178
5179 @override
5180 R errorUnresolvedConstructorInvoke(
5181 NewExpression node,
5182 Element constructor,
5183 DartType type,
5184 NodeList arguments,
5185 Selector selector,
5186 A arg) {
5187 apply(arguments, arg);
5188 return null;
5189 }
5190 R visitFactoryConstructorInvoke(
5191 NewExpression node,
5192 ConstructorElement constructor,
5193 InterfaceType type,
5194 NodeList arguments,
5195 Selector selector,
5196 A arg) {
5197 apply(arguments, arg);
5198 return null;
5199 }
5200
5201 @override
5202 R visitGenerativeConstructorInvoke(
5203 NewExpression node,
5204 ConstructorElement constructor,
5205 InterfaceType type,
5206 NodeList arguments,
5207 Selector selector,
5208 A arg) {
5209 apply(arguments, arg);
5210 return null;
5211 }
5212
5213 @override
5214 R visitRedirectingFactoryConstructorInvoke(
5215 NewExpression node,
5216 ConstructorElement constructor,
5217 InterfaceType type,
5218 ConstructorElement effectiveTarget,
5219 InterfaceType effectiveTargetType,
5220 NodeList arguments,
5221 Selector selector,
5222 A arg) {
5223 apply(arguments, arg);
5224 return null;
5225 }
5226
5227 @override
5228 R visitRedirectingGenerativeConstructorInvoke(
5229 NewExpression node,
5230 ConstructorElement constructor,
5231 InterfaceType type,
5232 NodeList arguments,
5233 Selector selector,
5234 A arg) {
5235 apply(arguments, arg);
5236 return null;
5237 }
5238
5239 @override
5240 R errorAbstractClassConstructorInvoke(
5241 NewExpression node,
5242 ConstructorElement element,
5243 InterfaceType type,
5244 NodeList arguments,
5245 Selector selector,
5246 A arg) {
5247 apply(arguments, arg);
5248 return null;
5249 }
5250
5251 @override
5252 R errorUnresolvedRedirectingFactoryConstructorInvoke(
5253 NewExpression node,
5254 ConstructorElement constructor,
5255 InterfaceType type,
5256 NodeList arguments,
5257 Selector selector,
5258 A arg) {
5259 apply(arguments, arg);
5260 return null;
5261 }
5262 } 5158 }
5263 5159
5264 /// AST visitor that visits all normal [Send] and [SendSet] nodes using the 5160 /// AST visitor that visits all normal [Send] and [SendSet] nodes using the
5265 /// [SemanticVisitor]. 5161 /// [SemanticVisitor].
5266 class TraversalVisitor<R, A> extends SemanticVisitor<R, A> 5162 class TraversalVisitor<R, A> extends SemanticVisitor<R, A>
5267 with TraversalSendMixin<R, A>, 5163 with TraversalSendMixin<R, A>,
5268 TraversalDeclarationMixin<R, A> { 5164 TraversalDeclarationMixin<R, A> {
5269 TraversalVisitor(TreeElements elements) : super(elements); 5165 TraversalVisitor(TreeElements elements) : super(elements);
5270 5166
5271 SemanticSendVisitor<R, A> get sendVisitor => this; 5167 SemanticSendVisitor<R, A> get sendVisitor => this;
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
5315 5211
5316 R handleStaticFieldGet( 5212 R handleStaticFieldGet(
5317 Send node, 5213 Send node,
5318 FieldElement field, 5214 FieldElement field,
5319 A arg); 5215 A arg);
5320 5216
5321 R handleStaticFieldInvoke( 5217 R handleStaticFieldInvoke(
5322 Send node, 5218 Send node,
5323 FieldElement field, 5219 FieldElement field,
5324 NodeList arguments, 5220 NodeList arguments,
5325 Selector selector, 5221 CallStructure callStructure,
5326 A arg); 5222 A arg);
5327 5223
5328 R handleStaticFieldPostfixPrefix( 5224 R handleStaticFieldPostfixPrefix(
5329 Send node, 5225 Send node,
5330 FieldElement field, 5226 FieldElement field,
5331 IncDecOperator operator, 5227 IncDecOperator operator,
5332 A arg, 5228 A arg,
5333 {bool isPrefix}); 5229 {bool isPrefix});
5334 5230
5335 R handleStaticFieldSet( 5231 R handleStaticFieldSet(
5336 SendSet node, 5232 SendSet node,
5337 FieldElement field, 5233 FieldElement field,
5338 Node rhs, 5234 Node rhs,
5339 A arg); 5235 A arg);
5340 5236
5341 R handleStaticFunctionGet( 5237 R handleStaticFunctionGet(
5342 Send node, 5238 Send node,
5343 MethodElement function, 5239 MethodElement function,
5344 A arg); 5240 A arg);
5345 5241
5346 R handleStaticFunctionInvoke( 5242 R handleStaticFunctionInvoke(
5347 Send node, 5243 Send node,
5348 MethodElement function, 5244 MethodElement function,
5349 NodeList arguments, 5245 NodeList arguments,
5350 Selector selector, 5246 CallStructure callStructure,
5351 A arg); 5247 A arg);
5352 5248
5353 R handleStaticGetterGet( 5249 R handleStaticGetterGet(
5354 Send node, 5250 Send node,
5355 FunctionElement getter, 5251 FunctionElement getter,
5356 A arg); 5252 A arg);
5357 5253
5358 R handleStaticGetterInvoke( 5254 R handleStaticGetterInvoke(
5359 Send node, 5255 Send node,
5360 FunctionElement getter, 5256 FunctionElement getter,
5361 NodeList arguments, 5257 NodeList arguments,
5362 Selector selector, 5258 CallStructure callStructure,
5363 A arg); 5259 A arg);
5364 5260
5365 R handleStaticGetterSetterCompound( 5261 R handleStaticGetterSetterCompound(
5366 Send node, 5262 Send node,
5367 FunctionElement getter, 5263 FunctionElement getter,
5368 FunctionElement setter, 5264 FunctionElement setter,
5369 AssignmentOperator operator, 5265 AssignmentOperator operator,
5370 Node rhs, 5266 Node rhs,
5371 A arg); 5267 A arg);
5372 5268
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
5416 FieldElement field, 5312 FieldElement field,
5417 A arg) { 5313 A arg) {
5418 return handleStaticFieldGet(node, field, arg); 5314 return handleStaticFieldGet(node, field, arg);
5419 } 5315 }
5420 5316
5421 @override 5317 @override
5422 R visitStaticFieldInvoke( 5318 R visitStaticFieldInvoke(
5423 Send node, 5319 Send node,
5424 FieldElement field, 5320 FieldElement field,
5425 NodeList arguments, 5321 NodeList arguments,
5426 Selector selector, 5322 CallStructure callStructure,
5427 A arg) { 5323 A arg) {
5428 return handleStaticFieldInvoke(node, field, arguments, selector, arg); 5324 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
5429 } 5325 }
5430 5326
5431 @override 5327 @override
5432 R visitStaticFieldPostfix( 5328 R visitStaticFieldPostfix(
5433 Send node, 5329 Send node,
5434 FieldElement field, 5330 FieldElement field,
5435 IncDecOperator operator, 5331 IncDecOperator operator,
5436 A arg) { 5332 A arg) {
5437 return handleStaticFieldPostfixPrefix( 5333 return handleStaticFieldPostfixPrefix(
5438 node, field, operator, arg, isPrefix: false); 5334 node, field, operator, arg, isPrefix: false);
(...skipping 24 matching lines...) Expand all
5463 MethodElement function, 5359 MethodElement function,
5464 A arg) { 5360 A arg) {
5465 return handleStaticFunctionGet(node, function, arg); 5361 return handleStaticFunctionGet(node, function, arg);
5466 } 5362 }
5467 5363
5468 @override 5364 @override
5469 R visitStaticFunctionInvoke( 5365 R visitStaticFunctionInvoke(
5470 Send node, 5366 Send node,
5471 MethodElement function, 5367 MethodElement function,
5472 NodeList arguments, 5368 NodeList arguments,
5473 Selector selector, 5369 CallStructure callStructure,
5474 A arg) { 5370 A arg) {
5475 return handleStaticFunctionInvoke(node, function, arguments, selector, arg); 5371 return handleStaticFunctionInvoke(
5372 node, function, arguments, callStructure, arg);
5476 } 5373 }
5477 5374
5478 @override 5375 @override
5479 R visitStaticGetterGet( 5376 R visitStaticGetterGet(
5480 Send node, 5377 Send node,
5481 FunctionElement getter, 5378 FunctionElement getter,
5482 A arg) { 5379 A arg) {
5483 return handleStaticGetterGet(node, getter, arg); 5380 return handleStaticGetterGet(node, getter, arg);
5484 } 5381 }
5485 5382
5486 @override 5383 @override
5487 R visitStaticGetterInvoke( 5384 R visitStaticGetterInvoke(
5488 Send node, 5385 Send node,
5489 FunctionElement getter, 5386 FunctionElement getter,
5490 NodeList arguments, 5387 NodeList arguments,
5491 Selector selector, 5388 CallStructure callStructure,
5492 A arg) { 5389 A arg) {
5493 return handleStaticGetterInvoke(node, getter, arguments, selector, arg); 5390 return handleStaticGetterInvoke(
5391 node, getter, arguments, callStructure, arg);
5494 } 5392 }
5495 5393
5496 @override 5394 @override
5497 R visitStaticGetterSetterCompound( 5395 R visitStaticGetterSetterCompound(
5498 Send node, 5396 Send node,
5499 FunctionElement getter, 5397 FunctionElement getter,
5500 FunctionElement setter, 5398 FunctionElement setter,
5501 AssignmentOperator operator, 5399 AssignmentOperator operator,
5502 Node rhs, 5400 Node rhs,
5503 A arg) { 5401 A arg) {
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after
5586 FieldElement field, 5484 FieldElement field,
5587 A arg) { 5485 A arg) {
5588 return handleStaticFieldGet(node, field, arg); 5486 return handleStaticFieldGet(node, field, arg);
5589 } 5487 }
5590 5488
5591 @override 5489 @override
5592 R visitTopLevelFieldInvoke( 5490 R visitTopLevelFieldInvoke(
5593 Send node, 5491 Send node,
5594 FieldElement field, 5492 FieldElement field,
5595 NodeList arguments, 5493 NodeList arguments,
5596 Selector selector, 5494 CallStructure callStructure,
5597 A arg) { 5495 A arg) {
5598 return handleStaticFieldInvoke(node, field, arguments, selector, arg); 5496 return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
5599 } 5497 }
5600 5498
5601 @override 5499 @override
5602 R visitTopLevelFieldPostfix( 5500 R visitTopLevelFieldPostfix(
5603 Send node, 5501 Send node,
5604 FieldElement field, 5502 FieldElement field,
5605 IncDecOperator operator, 5503 IncDecOperator operator,
5606 A arg) { 5504 A arg) {
5607 return handleStaticFieldPostfixPrefix( 5505 return handleStaticFieldPostfixPrefix(
5608 node, field, operator, arg, isPrefix: false); 5506 node, field, operator, arg, isPrefix: false);
(...skipping 24 matching lines...) Expand all
5633 MethodElement function, 5531 MethodElement function,
5634 A arg) { 5532 A arg) {
5635 return handleStaticFunctionGet(node, function, arg); 5533 return handleStaticFunctionGet(node, function, arg);
5636 } 5534 }
5637 5535
5638 @override 5536 @override
5639 R visitTopLevelFunctionInvoke( 5537 R visitTopLevelFunctionInvoke(
5640 Send node, 5538 Send node,
5641 MethodElement function, 5539 MethodElement function,
5642 NodeList arguments, 5540 NodeList arguments,
5643 Selector selector, 5541 CallStructure callStructure,
5644 A arg) { 5542 A arg) {
5645 return handleStaticFunctionInvoke(node, function, arguments, selector, arg); 5543 return handleStaticFunctionInvoke(
5544 node, function, arguments, callStructure, arg);
5646 } 5545 }
5647 5546
5648 @override 5547 @override
5649 R visitTopLevelGetterGet( 5548 R visitTopLevelGetterGet(
5650 Send node, 5549 Send node,
5651 FunctionElement getter, 5550 FunctionElement getter,
5652 A arg) { 5551 A arg) {
5653 return handleStaticGetterGet(node, getter, arg); 5552 return handleStaticGetterGet(node, getter, arg);
5654 } 5553 }
5655 5554
5656 @override 5555 @override
5657 R visitTopLevelGetterInvoke( 5556 R visitTopLevelGetterInvoke(
5658 Send node, 5557 Send node,
5659 FunctionElement getter, 5558 FunctionElement getter,
5660 NodeList arguments, 5559 NodeList arguments,
5661 Selector selector, 5560 CallStructure callStructure,
5662 A arg) { 5561 A arg) {
5663 return handleStaticGetterInvoke(node, getter, arguments, selector, arg); 5562 return handleStaticGetterInvoke(
5563 node, getter, arguments, callStructure, arg);
5664 } 5564 }
5665 5565
5666 @override 5566 @override
5667 R visitTopLevelGetterSetterCompound( 5567 R visitTopLevelGetterSetterCompound(
5668 Send node, 5568 Send node,
5669 FunctionElement getter, 5569 FunctionElement getter,
5670 FunctionElement setter, 5570 FunctionElement setter,
5671 AssignmentOperator operator, 5571 AssignmentOperator operator,
5672 Node rhs, 5572 Node rhs,
5673 A arg) { 5573 A arg) {
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after
5757 5657
5758 R handleLocalGet( 5658 R handleLocalGet(
5759 Send node, 5659 Send node,
5760 LocalElement element, 5660 LocalElement element,
5761 A arg); 5661 A arg);
5762 5662
5763 R handleLocalInvoke( 5663 R handleLocalInvoke(
5764 Send node, 5664 Send node,
5765 LocalElement element, 5665 LocalElement element,
5766 NodeList arguments, 5666 NodeList arguments,
5767 Selector selector, 5667 CallStructure callStructure,
5768 A arg); 5668 A arg);
5769 5669
5770 R handleLocalPostfixPrefix( 5670 R handleLocalPostfixPrefix(
5771 Send node, 5671 Send node,
5772 LocalElement element, 5672 LocalElement element,
5773 IncDecOperator operator, 5673 IncDecOperator operator,
5774 A arg, 5674 A arg,
5775 {bool isPrefix}); 5675 {bool isPrefix});
5776 5676
5777 R handleLocalSet( 5677 R handleLocalSet(
5778 SendSet node, 5678 SendSet node,
5779 LocalElement element, 5679 LocalElement element,
5780 Node rhs, 5680 Node rhs,
5781 A arg); 5681 A arg);
5782 5682
5783 @override 5683 @override
5784 R visitLocalFunctionGet( 5684 R visitLocalFunctionGet(
5785 Send node, 5685 Send node,
5786 LocalFunctionElement function, 5686 LocalFunctionElement function,
5787 A arg) { 5687 A arg) {
5788 return handleLocalGet(node, function, arg); 5688 return handleLocalGet(node, function, arg);
5789 } 5689 }
5790 5690
5791 @override 5691 @override
5792 R visitLocalFunctionInvoke( 5692 R visitLocalFunctionInvoke(
5793 Send node, 5693 Send node,
5794 LocalFunctionElement function, 5694 LocalFunctionElement function,
5795 NodeList arguments, 5695 NodeList arguments,
5796 Selector selector, 5696 CallStructure callStructure,
5797 A arg) { 5697 A arg) {
5798 return handleLocalInvoke(node, function, arguments, selector, arg); 5698 return handleLocalInvoke(node, function, arguments, callStructure, arg);
5799 } 5699 }
5800 5700
5801 @override 5701 @override
5802 R visitLocalVariableCompound( 5702 R visitLocalVariableCompound(
5803 Send node, 5703 Send node,
5804 LocalVariableElement variable, 5704 LocalVariableElement variable,
5805 AssignmentOperator operator, 5705 AssignmentOperator operator,
5806 Node rhs, 5706 Node rhs,
5807 A arg) { 5707 A arg) {
5808 return handleLocalCompound(node, variable, operator, rhs, arg); 5708 return handleLocalCompound(node, variable, operator, rhs, arg);
5809 } 5709 }
5810 5710
5811 @override 5711 @override
5812 R visitLocalVariableGet( 5712 R visitLocalVariableGet(
5813 Send node, 5713 Send node,
5814 LocalVariableElement variable, 5714 LocalVariableElement variable,
5815 A arg) { 5715 A arg) {
5816 return handleLocalGet(node, variable, arg); 5716 return handleLocalGet(node, variable, arg);
5817 } 5717 }
5818 5718
5819 @override 5719 @override
5820 R visitLocalVariableInvoke( 5720 R visitLocalVariableInvoke(
5821 Send node, 5721 Send node,
5822 LocalVariableElement variable, 5722 LocalVariableElement variable,
5823 NodeList arguments, 5723 NodeList arguments,
5824 Selector selector, 5724 CallStructure callStructure,
5825 A arg) { 5725 A arg) {
5826 return handleLocalInvoke(node, variable, arguments, selector, arg); 5726 return handleLocalInvoke(node, variable, arguments, callStructure, arg);
5827 } 5727 }
5828 5728
5829 @override 5729 @override
5830 R visitLocalVariablePostfix( 5730 R visitLocalVariablePostfix(
5831 Send node, 5731 Send node,
5832 LocalVariableElement variable, 5732 LocalVariableElement variable,
5833 IncDecOperator operator, 5733 IncDecOperator operator,
5834 A arg) { 5734 A arg) {
5835 return handleLocalPostfixPrefix( 5735 return handleLocalPostfixPrefix(
5836 node, variable, operator, arg, isPrefix: false); 5736 node, variable, operator, arg, isPrefix: false);
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
5871 ParameterElement parameter, 5771 ParameterElement parameter,
5872 A arg) { 5772 A arg) {
5873 return handleLocalGet(node, parameter, arg); 5773 return handleLocalGet(node, parameter, arg);
5874 } 5774 }
5875 5775
5876 @override 5776 @override
5877 R visitParameterInvoke( 5777 R visitParameterInvoke(
5878 Send node, 5778 Send node,
5879 ParameterElement parameter, 5779 ParameterElement parameter,
5880 NodeList arguments, 5780 NodeList arguments,
5881 Selector selector, 5781 CallStructure callStructure,
5882 A arg) { 5782 A arg) {
5883 return handleLocalInvoke(node, parameter, arguments, selector, arg); 5783 return handleLocalInvoke(node, parameter, arguments, callStructure, arg);
5884 } 5784 }
5885 5785
5886 @override 5786 @override
5887 R visitParameterPostfix( 5787 R visitParameterPostfix(
5888 Send node, 5788 Send node,
5889 ParameterElement parameter, 5789 ParameterElement parameter,
5890 IncDecOperator operator, 5790 IncDecOperator operator,
5891 A arg) { 5791 A arg) {
5892 return handleLocalPostfixPrefix( 5792 return handleLocalPostfixPrefix(
5893 node, parameter, operator, arg, isPrefix: false); 5793 node, parameter, operator, arg, isPrefix: false);
(...skipping 28 matching lines...) Expand all
5922 implements SemanticSendVisitor<R, A> { 5822 implements SemanticSendVisitor<R, A> {
5923 R handleConstantGet( 5823 R handleConstantGet(
5924 Node node, 5824 Node node,
5925 ConstantExpression constant, 5825 ConstantExpression constant,
5926 A arg); 5826 A arg);
5927 5827
5928 R handleConstantInvoke( 5828 R handleConstantInvoke(
5929 Send node, 5829 Send node,
5930 ConstantExpression constant, 5830 ConstantExpression constant,
5931 NodeList arguments, 5831 NodeList arguments,
5932 Selector selector, 5832 CallStructure callStructure,
5933 A arg); 5833 A arg);
5934 5834
5935 @override 5835 @override
5936 R visitClassTypeLiteralGet( 5836 R visitClassTypeLiteralGet(
5937 Send node, 5837 Send node,
5938 ConstantExpression constant, 5838 ConstantExpression constant,
5939 A arg) { 5839 A arg) {
5940 return handleConstantGet(node, constant, arg); 5840 return handleConstantGet(node, constant, arg);
5941 } 5841 }
5942 5842
5943 @override 5843 @override
5944 R visitClassTypeLiteralInvoke( 5844 R visitClassTypeLiteralInvoke(
5945 Send node, 5845 Send node,
5946 ConstantExpression constant, 5846 ConstantExpression constant,
5947 NodeList arguments, 5847 NodeList arguments,
5948 Selector selector, 5848 CallStructure callStructure,
5949 A arg) { 5849 A arg) {
5950 return handleConstantInvoke(node, constant, arguments, selector, arg); 5850 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
5951 } 5851 }
5952 5852
5953 @override 5853 @override
5954 R visitConstConstructorInvoke( 5854 R visitConstConstructorInvoke(
5955 NewExpression node, 5855 NewExpression node,
5956 ConstructedConstantExpression constant, 5856 ConstructedConstantExpression constant,
5957 A arg) { 5857 A arg) {
5958 return handleConstantGet(node, constant, arg); 5858 return handleConstantGet(node, constant, arg);
5959 } 5859 }
5960 5860
5961 @override 5861 @override
5962 R visitConstantGet( 5862 R visitConstantGet(
5963 Send node, 5863 Send node,
5964 ConstantExpression constant, 5864 ConstantExpression constant,
5965 A arg) { 5865 A arg) {
5966 return handleConstantGet(node, constant, arg); 5866 return handleConstantGet(node, constant, arg);
5967 } 5867 }
5968 5868
5969 @override 5869 @override
5970 R visitConstantInvoke( 5870 R visitConstantInvoke(
5971 Send node, 5871 Send node,
5972 ConstantExpression constant, 5872 ConstantExpression constant,
5973 NodeList arguments, 5873 NodeList arguments,
5974 Selector selector, 5874 CallStructure callStructure,
5975 A arg) { 5875 A arg) {
5976 return handleConstantInvoke(node, constant, arguments, selector, arg); 5876 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
5977 } 5877 }
5978 5878
5979 @override 5879 @override
5980 R visitDynamicTypeLiteralGet( 5880 R visitDynamicTypeLiteralGet(
5981 Send node, 5881 Send node,
5982 ConstantExpression constant, 5882 ConstantExpression constant,
5983 A arg) { 5883 A arg) {
5984 return handleConstantGet(node, constant, arg); 5884 return handleConstantGet(node, constant, arg);
5985 } 5885 }
5986 5886
5987 @override 5887 @override
5988 R visitDynamicTypeLiteralInvoke( 5888 R visitDynamicTypeLiteralInvoke(
5989 Send node, 5889 Send node,
5990 ConstantExpression constant, 5890 ConstantExpression constant,
5991 NodeList arguments, 5891 NodeList arguments,
5992 Selector selector, 5892 CallStructure callStructure,
5993 A arg) { 5893 A arg) {
5994 return handleConstantInvoke(node, constant, arguments, selector, arg); 5894 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
5995 } 5895 }
5996 5896
5997 @override 5897 @override
5998 R visitTypedefTypeLiteralGet( 5898 R visitTypedefTypeLiteralGet(
5999 Send node, 5899 Send node,
6000 ConstantExpression constant, 5900 ConstantExpression constant,
6001 A arg) { 5901 A arg) {
6002 return handleConstantGet(node, constant, arg); 5902 return handleConstantGet(node, constant, arg);
6003 } 5903 }
6004 5904
6005 @override 5905 @override
6006 R visitTypedefTypeLiteralInvoke( 5906 R visitTypedefTypeLiteralInvoke(
6007 Send node, 5907 Send node,
6008 ConstantExpression constant, 5908 ConstantExpression constant,
6009 NodeList arguments, 5909 NodeList arguments,
6010 Selector selector, 5910 CallStructure callStructure,
6011 A arg) { 5911 A arg) {
6012 return handleConstantInvoke(node, constant, arguments, selector, arg); 5912 return handleConstantInvoke(node, constant, arguments, callStructure, arg);
6013 } 5913 }
6014 } 5914 }
6015 5915
6016 /// Mixin that groups all `visitDynamicPropertyX` and `visitThisPropertyY` 5916 /// Mixin that groups all `visitDynamicPropertyX` and `visitThisPropertyY`
6017 /// methods for by delegating calls to `handleDynamicX` methods, providing 5917 /// methods for by delegating calls to `handleDynamicX` methods, providing
6018 /// `null` as the receiver for the this properties. 5918 /// `null` as the receiver for the this properties.
6019 /// 5919 ///
6020 /// This mixin is useful for the cases where dynamic and this properties are 5920 /// This mixin is useful for the cases where dynamic and this properties are
6021 /// handled uniformly. 5921 /// handled uniformly.
6022 abstract class BaseImplementationOfDynamicsMixin<R, A> 5922 abstract class BaseImplementationOfDynamicsMixin<R, A>
(...skipping 416 matching lines...) Expand 10 before | Expand all | Expand 10 after
6439 /// This mixin is useful for the cases where all constructor invocations are 6339 /// This mixin is useful for the cases where all constructor invocations are
6440 /// handled uniformly. 6340 /// handled uniformly.
6441 abstract class BaseImplementationOfNewMixin<R, A> 6341 abstract class BaseImplementationOfNewMixin<R, A>
6442 implements SemanticSendVisitor<R, A> { 6342 implements SemanticSendVisitor<R, A> {
6443 6343
6444 R handleConstructorInvoke( 6344 R handleConstructorInvoke(
6445 NewExpression node, 6345 NewExpression node,
6446 ConstructorElement constructor, 6346 ConstructorElement constructor,
6447 DartType type, 6347 DartType type,
6448 NodeList arguments, 6348 NodeList arguments,
6449 Selector selector, 6349 CallStructure callStructure,
6450 A arg); 6350 A arg);
6451 6351
6452 R visitGenerativeConstructorInvoke( 6352 R visitGenerativeConstructorInvoke(
6453 NewExpression node, 6353 NewExpression node,
6454 ConstructorElement constructor, 6354 ConstructorElement constructor,
6455 InterfaceType type, 6355 InterfaceType type,
6456 NodeList arguments, 6356 NodeList arguments,
6457 Selector selector, 6357 CallStructure callStructure,
6458 A arg) { 6358 A arg) {
6459 return handleConstructorInvoke( 6359 return handleConstructorInvoke(
6460 node, constructor, type, arguments, selector, arg); 6360 node, constructor, type, arguments, callStructure, arg);
6461 } 6361 }
6462 6362
6463 R visitRedirectingGenerativeConstructorInvoke( 6363 R visitRedirectingGenerativeConstructorInvoke(
6464 NewExpression node, 6364 NewExpression node,
6465 ConstructorElement constructor, 6365 ConstructorElement constructor,
6466 InterfaceType type, 6366 InterfaceType type,
6467 NodeList arguments, 6367 NodeList arguments,
6468 Selector selector, 6368 CallStructure callStructure,
6469 A arg) { 6369 A arg) {
6470 return handleConstructorInvoke( 6370 return handleConstructorInvoke(
6471 node, constructor, type, arguments, selector, arg); 6371 node, constructor, type, arguments, callStructure, arg);
6472 } 6372 }
6473 6373
6474 R visitFactoryConstructorInvoke( 6374 R visitFactoryConstructorInvoke(
6475 NewExpression node, 6375 NewExpression node,
6476 ConstructorElement constructor, 6376 ConstructorElement constructor,
6477 InterfaceType type, 6377 InterfaceType type,
6478 NodeList arguments, 6378 NodeList arguments,
6479 Selector selector, 6379 CallStructure callStructure,
6480 A arg) { 6380 A arg) {
6481 return handleConstructorInvoke( 6381 return handleConstructorInvoke(
6482 node, constructor, type, arguments, selector, arg); 6382 node, constructor, type, arguments, callStructure, arg);
6483 } 6383 }
6484 6384
6485 R visitRedirectingFactoryConstructorInvoke( 6385 R visitRedirectingFactoryConstructorInvoke(
6486 NewExpression node, 6386 NewExpression node,
6487 ConstructorElement constructor, 6387 ConstructorElement constructor,
6488 InterfaceType type, 6388 InterfaceType type,
6489 ConstructorElement effectiveTarget, 6389 ConstructorElement effectiveTarget,
6490 InterfaceType effectiveTargetType, 6390 InterfaceType effectiveTargetType,
6491 NodeList arguments, 6391 NodeList arguments,
6492 Selector selector, 6392 CallStructure callStructure,
6493 A arg) { 6393 A arg) {
6494 return handleConstructorInvoke( 6394 return handleConstructorInvoke(
6495 node, constructor, type, arguments, selector, arg); 6395 node, constructor, type, arguments, callStructure, arg);
6496 } 6396 }
6497 } 6397 }
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