OLD | NEW |
1 // Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2017, 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 import 'package:front_end/src/fasta/fasta_codes.dart'; | 5 import 'package:front_end/src/fasta/fasta_codes.dart'; |
6 import 'package:front_end/src/fasta/parser/identifier_context.dart' | 6 import 'package:front_end/src/fasta/parser/identifier_context.dart' |
7 show IdentifierContext; | 7 show IdentifierContext; |
8 import 'package:front_end/src/fasta/parser.dart' as fasta; | 8 import 'package:front_end/src/fasta/parser.dart' as fasta; |
9 import 'package:front_end/src/fasta/scanner/token.dart' as fasta; | 9 import 'package:front_end/src/fasta/scanner/token.dart' as fasta; |
10 import 'package:front_end/src/fasta/util/link.dart'; | 10 import 'package:front_end/src/fasta/util/link.dart'; |
11 import 'package:front_end/src/scanner/token.dart'; | 11 import 'package:front_end/src/scanner/token.dart'; |
12 import 'package:test/test.dart'; | 12 import 'package:test/test.dart'; |
13 | 13 |
14 /** | 14 /** |
15 * Proxy implementation of the fasta parser listener that | 15 * Proxy implementation of the fasta parser listener that |
16 * asserts begin/end pairs of events and forwards all events | 16 * asserts begin/end pairs of events and forwards all events |
17 * to the specified listener. | 17 * to the specified listener. |
| 18 * |
| 19 * When `parseUnit` is called, then all events are generated as expected. |
| 20 * When "lower level" parse methods are called, then some "higher level" |
| 21 * begin/end event pairs will not be generated. In this case, |
| 22 * construct a new listener and call `begin('higher-level-event')` |
| 23 * before calling the "lower level" parse method. Once the parse method returns, |
| 24 * call `end('higher-level-event')` to assert that the stack is in the |
| 25 * expected state. |
| 26 * |
| 27 * For example, when calling `parseTopLevelDeclaration`, the |
| 28 * [beginCompilationUnit] and [endCompilationUnit] event pair is not generated. |
| 29 * In this case, call `begin('CompilationUnit')` before calling |
| 30 * `parseTopLevelDeclaration`, and call `end('CompilationUnit')` afterward. |
| 31 * |
| 32 * When calling `parseUnit`, do not call `begin` or `end`, |
| 33 * but call `expectEmpty` after `parseUnit` returns. |
18 */ | 34 */ |
19 class ForwardingTestListener implements fasta.Listener { | 35 class ForwardingTestListener implements fasta.Listener { |
20 final fasta.Listener listener; | 36 final fasta.Listener listener; |
21 final _stack = <String>[]; | 37 final _stack = <String>[]; |
22 | 38 |
23 void _begin(String event) { | 39 void begin(String event) { |
| 40 expect(event, isNotNull); |
24 _stack.add(event); | 41 _stack.add(event); |
25 } | 42 } |
26 | 43 |
27 void _in(String event) { | 44 void expectEmpty() { |
| 45 expect(_stack, isEmpty); |
| 46 } |
| 47 |
| 48 void expectIn(String event) { |
28 if (_stack.isEmpty || _stack.last != event) { | 49 if (_stack.isEmpty || _stack.last != event) { |
29 fail('Expected $event, but found $_stack'); | 50 fail('Expected $event, but found $_stack'); |
30 } | 51 } |
31 } | 52 } |
32 | 53 |
33 void _end(String event) { | 54 void end(String event) { |
34 _in(event); | 55 expectIn(event); |
35 _stack.removeLast(); | 56 _stack.removeLast(); |
36 } | 57 } |
37 | 58 |
38 ForwardingTestListener(this.listener); | 59 ForwardingTestListener(this.listener); |
39 | 60 |
40 @override | 61 @override |
41 void beginArguments(Token token) { | 62 void beginArguments(Token token) { |
42 listener.beginArguments(token); | 63 listener.beginArguments(token); |
43 _begin('Arguments'); | 64 begin('Arguments'); |
44 } | 65 } |
45 | 66 |
46 @override | 67 @override |
47 void beginAssert(Token assertKeyword, fasta.Assert kind) { | 68 void beginAssert(Token assertKeyword, fasta.Assert kind) { |
48 listener.beginAssert(assertKeyword, kind); | 69 listener.beginAssert(assertKeyword, kind); |
49 _begin('Assert'); | 70 begin('Assert'); |
50 } | 71 } |
51 | 72 |
52 @override | 73 @override |
53 void beginAwaitExpression(Token token) { | 74 void beginAwaitExpression(Token token) { |
54 listener.beginAwaitExpression(token); | 75 listener.beginAwaitExpression(token); |
55 _begin('AwaitExpression'); | 76 begin('AwaitExpression'); |
56 } | 77 } |
57 | 78 |
58 @override | 79 @override |
59 void beginBlock(Token token) { | 80 void beginBlock(Token token) { |
60 listener.beginBlock(token); | 81 listener.beginBlock(token); |
61 _begin('Block'); | 82 begin('Block'); |
62 } | 83 } |
63 | 84 |
64 @override | 85 @override |
65 void beginBlockFunctionBody(Token token) { | 86 void beginBlockFunctionBody(Token token) { |
66 listener.beginBlockFunctionBody(token); | 87 listener.beginBlockFunctionBody(token); |
67 _begin('BlockFunctionBody'); | 88 begin('BlockFunctionBody'); |
68 } | 89 } |
69 | 90 |
70 @override | 91 @override |
71 void beginCascade(Token token) { | 92 void beginCascade(Token token) { |
72 listener.beginCascade(token); | 93 listener.beginCascade(token); |
73 _begin('Cascade'); | 94 begin('Cascade'); |
74 } | 95 } |
75 | 96 |
76 @override | 97 @override |
77 void beginCaseExpression(Token caseKeyword) { | 98 void beginCaseExpression(Token caseKeyword) { |
78 listener.beginCaseExpression(caseKeyword); | 99 listener.beginCaseExpression(caseKeyword); |
79 _begin('CaseExpression'); | 100 begin('CaseExpression'); |
80 } | 101 } |
81 | 102 |
82 @override | 103 @override |
83 void beginCatchClause(Token token) { | 104 void beginCatchClause(Token token) { |
84 listener.beginCatchClause(token); | 105 listener.beginCatchClause(token); |
85 _begin('CatchClause'); | 106 begin('CatchClause'); |
86 } | 107 } |
87 | 108 |
88 @override | 109 @override |
89 void beginClassBody(Token token) { | 110 void beginClassBody(Token token) { |
90 listener.beginClassBody(token); | 111 listener.beginClassBody(token); |
91 _begin('ClassBody'); | 112 begin('ClassBody'); |
92 } | 113 } |
93 | 114 |
94 @override | 115 @override |
95 void beginClassDeclaration(Token beginToken, Token name) { | 116 void beginClassDeclaration(Token beginToken, Token name) { |
96 listener.beginClassDeclaration(beginToken, name); | 117 listener.beginClassDeclaration(beginToken, name); |
97 _begin('ClassDeclaration'); | 118 begin('ClassDeclaration'); |
98 } | 119 } |
99 | 120 |
100 @override | 121 @override |
101 void beginClassOrNamedMixinApplication(Token token) { | 122 void beginClassOrNamedMixinApplication(Token token) { |
102 listener.beginClassOrNamedMixinApplication(token); | 123 listener.beginClassOrNamedMixinApplication(token); |
103 _begin('ClassOrNamedMixinApplication'); | 124 begin('ClassOrNamedMixinApplication'); |
104 } | 125 } |
105 | 126 |
106 @override | 127 @override |
107 void beginCombinators(Token token) { | 128 void beginCombinators(Token token) { |
108 listener.beginCombinators(token); | 129 listener.beginCombinators(token); |
109 _begin('Combinators'); | 130 begin('Combinators'); |
110 } | 131 } |
111 | 132 |
112 @override | 133 @override |
113 void beginCompilationUnit(Token token) { | 134 void beginCompilationUnit(Token token) { |
| 135 expectEmpty(); |
114 listener.beginCompilationUnit(token); | 136 listener.beginCompilationUnit(token); |
115 _begin('CompilationUnit'); | 137 begin('CompilationUnit'); |
116 } | 138 } |
117 | 139 |
118 @override | 140 @override |
119 void beginConditionalUri(Token ifKeyword) { | 141 void beginConditionalUri(Token ifKeyword) { |
120 listener.beginConditionalUri(ifKeyword); | 142 listener.beginConditionalUri(ifKeyword); |
121 _begin('ConditionalUri'); | 143 begin('ConditionalUri'); |
122 } | 144 } |
123 | 145 |
124 @override | 146 @override |
125 void beginConditionalUris(Token token) { | 147 void beginConditionalUris(Token token) { |
126 listener.beginConditionalUris(token); | 148 listener.beginConditionalUris(token); |
127 _begin('ConditionalUris'); | 149 begin('ConditionalUris'); |
128 } | 150 } |
129 | 151 |
130 @override | 152 @override |
131 void beginConstExpression(Token constKeyword) { | 153 void beginConstExpression(Token constKeyword) { |
132 listener.beginConstExpression(constKeyword); | 154 listener.beginConstExpression(constKeyword); |
133 _begin('ConstExpression'); | 155 begin('ConstExpression'); |
134 } | 156 } |
135 | 157 |
136 @override | 158 @override |
137 void beginConstLiteral(Token token) { | 159 void beginConstLiteral(Token token) { |
138 listener.beginConstLiteral(token); | 160 listener.beginConstLiteral(token); |
139 _begin('ConstLiteral'); | 161 begin('ConstLiteral'); |
140 } | 162 } |
141 | 163 |
142 @override | 164 @override |
143 void beginConstructorReference(Token start) { | 165 void beginConstructorReference(Token start) { |
144 listener.beginConstructorReference(start); | 166 listener.beginConstructorReference(start); |
145 _begin('ConstructorReference'); | 167 begin('ConstructorReference'); |
146 } | 168 } |
147 | 169 |
148 @override | 170 @override |
149 void beginDoWhileStatement(Token token) { | 171 void beginDoWhileStatement(Token token) { |
150 listener.beginDoWhileStatement(token); | 172 listener.beginDoWhileStatement(token); |
151 _begin('DoWhileStatement'); | 173 begin('DoWhileStatement'); |
152 } | 174 } |
153 | 175 |
154 @override | 176 @override |
155 void beginDoWhileStatementBody(Token token) { | 177 void beginDoWhileStatementBody(Token token) { |
156 listener.beginDoWhileStatementBody(token); | 178 listener.beginDoWhileStatementBody(token); |
157 _begin('DoWhileStatementBody'); | 179 begin('DoWhileStatementBody'); |
158 } | 180 } |
159 | 181 |
160 @override | 182 @override |
161 void beginDottedName(Token token) { | 183 void beginDottedName(Token token) { |
162 listener.beginDottedName(token); | 184 listener.beginDottedName(token); |
163 _begin('DottedName'); | 185 begin('DottedName'); |
164 } | 186 } |
165 | 187 |
166 @override | 188 @override |
167 void beginElseStatement(Token token) { | 189 void beginElseStatement(Token token) { |
168 listener.beginElseStatement(token); | 190 listener.beginElseStatement(token); |
169 _begin('ElseStatement'); | 191 begin('ElseStatement'); |
170 } | 192 } |
171 | 193 |
172 @override | 194 @override |
173 void beginEnum(Token enumKeyword) { | 195 void beginEnum(Token enumKeyword) { |
174 listener.beginEnum(enumKeyword); | 196 listener.beginEnum(enumKeyword); |
175 _begin('Enum'); | 197 begin('Enum'); |
176 } | 198 } |
177 | 199 |
178 @override | 200 @override |
179 void beginExport(Token token) { | 201 void beginExport(Token token) { |
180 listener.beginExport(token); | 202 listener.beginExport(token); |
181 _begin('Export'); | 203 begin('Export'); |
182 } | 204 } |
183 | 205 |
184 @override | 206 @override |
185 void beginExpressionStatement(Token token) { | 207 void beginExpressionStatement(Token token) { |
186 listener.beginExpressionStatement(token); | 208 listener.beginExpressionStatement(token); |
187 _begin('ExpressionStatement'); | 209 begin('ExpressionStatement'); |
188 } | 210 } |
189 | 211 |
190 @override | 212 @override |
191 void beginFactoryMethod(Token token) { | 213 void beginFactoryMethod(Token token) { |
192 listener.beginFactoryMethod(token); | 214 listener.beginFactoryMethod(token); |
193 _begin('FactoryMethod'); | 215 begin('FactoryMethod'); |
194 } | 216 } |
195 | 217 |
196 @override | 218 @override |
197 void beginFieldInitializer(Token token) { | 219 void beginFieldInitializer(Token token) { |
198 listener.beginFieldInitializer(token); | 220 listener.beginFieldInitializer(token); |
199 _begin('FieldInitializer'); | 221 begin('FieldInitializer'); |
200 } | 222 } |
201 | 223 |
202 @override | 224 @override |
203 void beginForInBody(Token token) { | 225 void beginForInBody(Token token) { |
204 listener.beginForInBody(token); | 226 listener.beginForInBody(token); |
205 _begin('ForInBody'); | 227 begin('ForInBody'); |
206 } | 228 } |
207 | 229 |
208 @override | 230 @override |
209 void beginForInExpression(Token token) { | 231 void beginForInExpression(Token token) { |
210 listener.beginForInExpression(token); | 232 listener.beginForInExpression(token); |
211 _begin('ForInExpression'); | 233 begin('ForInExpression'); |
212 } | 234 } |
213 | 235 |
214 @override | 236 @override |
215 void beginForStatement(Token token) { | 237 void beginForStatement(Token token) { |
216 listener.beginForStatement(token); | 238 listener.beginForStatement(token); |
217 _begin('ForStatement'); | 239 begin('ForStatement'); |
218 } | 240 } |
219 | 241 |
220 @override | 242 @override |
221 void beginForStatementBody(Token token) { | 243 void beginForStatementBody(Token token) { |
222 listener.beginForStatementBody(token); | 244 listener.beginForStatementBody(token); |
223 _begin('ForStatementBody'); | 245 begin('ForStatementBody'); |
224 } | 246 } |
225 | 247 |
226 @override | 248 @override |
227 void beginFormalParameter(Token token, fasta.MemberKind kind) { | 249 void beginFormalParameter(Token token, fasta.MemberKind kind) { |
228 listener.beginFormalParameter(token, kind); | 250 listener.beginFormalParameter(token, kind); |
229 _begin('FormalParameter'); | 251 begin('FormalParameter'); |
230 } | 252 } |
231 | 253 |
232 @override | 254 @override |
233 void beginFormalParameters(Token token, fasta.MemberKind kind) { | 255 void beginFormalParameters(Token token, fasta.MemberKind kind) { |
234 listener.beginFormalParameters(token, kind); | 256 listener.beginFormalParameters(token, kind); |
235 _begin('FormalParameters'); | 257 begin('FormalParameters'); |
236 } | 258 } |
237 | 259 |
238 @override | 260 @override |
239 void beginLocalFunctionDeclaration(Token token) { | 261 void beginLocalFunctionDeclaration(Token token) { |
240 listener.beginLocalFunctionDeclaration(token); | 262 listener.beginLocalFunctionDeclaration(token); |
241 _begin('LocalFunctionDeclaration'); | 263 begin('LocalFunctionDeclaration'); |
242 } | 264 } |
243 | 265 |
244 @override | 266 @override |
245 void beginFunctionExpression(Token token) { | 267 void beginFunctionExpression(Token token) { |
246 listener.beginFunctionExpression(token); | 268 listener.beginFunctionExpression(token); |
247 _begin('FunctionExpression'); | 269 begin('FunctionExpression'); |
248 } | 270 } |
249 | 271 |
250 @override | 272 @override |
251 void beginFunctionName(Token token) { | 273 void beginFunctionName(Token token) { |
252 listener.beginFunctionName(token); | 274 listener.beginFunctionName(token); |
253 _begin('FunctionName'); | 275 begin('FunctionName'); |
254 } | 276 } |
255 | 277 |
256 @override | 278 @override |
257 void beginFunctionType(Token beginToken) { | 279 void beginFunctionType(Token beginToken) { |
258 listener.beginFunctionType(beginToken); | 280 listener.beginFunctionType(beginToken); |
259 _begin('FunctionType'); | 281 begin('FunctionType'); |
260 } | 282 } |
261 | 283 |
262 @override | 284 @override |
263 void beginFunctionTypeAlias(Token token) { | 285 void beginFunctionTypeAlias(Token token) { |
264 listener.beginFunctionTypeAlias(token); | 286 listener.beginFunctionTypeAlias(token); |
265 _begin('FunctionTypeAlias'); | 287 begin('FunctionTypeAlias'); |
266 } | 288 } |
267 | 289 |
268 @override | 290 @override |
269 void beginFunctionTypedFormalParameter(Token token) { | 291 void beginFunctionTypedFormalParameter(Token token) { |
270 listener.beginFunctionTypedFormalParameter(token); | 292 listener.beginFunctionTypedFormalParameter(token); |
271 _begin('FunctionTypedFormalParameter'); | 293 begin('FunctionTypedFormalParameter'); |
272 } | 294 } |
273 | 295 |
274 @override | 296 @override |
275 void beginHide(Token hideKeyword) { | 297 void beginHide(Token hideKeyword) { |
276 listener.beginHide(hideKeyword); | 298 listener.beginHide(hideKeyword); |
277 _begin('Hide'); | 299 begin('Hide'); |
278 } | 300 } |
279 | 301 |
280 @override | 302 @override |
281 void beginIdentifierList(Token token) { | 303 void beginIdentifierList(Token token) { |
282 listener.beginIdentifierList(token); | 304 listener.beginIdentifierList(token); |
283 _begin('IdentifierList'); | 305 begin('IdentifierList'); |
284 } | 306 } |
285 | 307 |
286 @override | 308 @override |
287 void beginIfStatement(Token token) { | 309 void beginIfStatement(Token token) { |
288 listener.beginIfStatement(token); | 310 listener.beginIfStatement(token); |
289 _begin('IfStatement'); | 311 begin('IfStatement'); |
290 } | 312 } |
291 | 313 |
292 @override | 314 @override |
293 void beginImport(Token importKeyword) { | 315 void beginImport(Token importKeyword) { |
294 listener.beginImport(importKeyword); | 316 listener.beginImport(importKeyword); |
295 _begin('Import'); | 317 begin('Import'); |
296 } | 318 } |
297 | 319 |
298 @override | 320 @override |
299 void beginInitializedIdentifier(Token token) { | 321 void beginInitializedIdentifier(Token token) { |
300 listener.beginInitializedIdentifier(token); | 322 listener.beginInitializedIdentifier(token); |
301 _begin('InitializedIdentifier'); | 323 begin('InitializedIdentifier'); |
302 } | 324 } |
303 | 325 |
304 @override | 326 @override |
305 void beginInitializer(Token token) { | 327 void beginInitializer(Token token) { |
306 listener.beginInitializer(token); | 328 listener.beginInitializer(token); |
307 _begin('Initializer'); | 329 begin('Initializer'); |
308 } | 330 } |
309 | 331 |
310 @override | 332 @override |
311 void beginInitializers(Token token) { | 333 void beginInitializers(Token token) { |
312 listener.beginInitializers(token); | 334 listener.beginInitializers(token); |
313 _begin('Initializers'); | 335 begin('Initializers'); |
314 } | 336 } |
315 | 337 |
316 @override | 338 @override |
317 void beginLabeledStatement(Token token, int labelCount) { | 339 void beginLabeledStatement(Token token, int labelCount) { |
318 listener.beginLabeledStatement(token, labelCount); | 340 listener.beginLabeledStatement(token, labelCount); |
319 _begin('LabeledStatement'); | 341 begin('LabeledStatement'); |
320 } | 342 } |
321 | 343 |
322 @override | 344 @override |
323 void beginLibraryName(Token token) { | 345 void beginLibraryName(Token token) { |
324 listener.beginLibraryName(token); | 346 listener.beginLibraryName(token); |
325 _begin('LibraryName'); | 347 begin('LibraryName'); |
326 } | 348 } |
327 | 349 |
328 @override | 350 @override |
329 void beginLiteralMapEntry(Token token) { | 351 void beginLiteralMapEntry(Token token) { |
330 listener.beginLiteralMapEntry(token); | 352 listener.beginLiteralMapEntry(token); |
331 _begin('LiteralMapEntry'); | 353 begin('LiteralMapEntry'); |
332 } | 354 } |
333 | 355 |
334 @override | 356 @override |
335 void beginLiteralString(Token token) { | 357 void beginLiteralString(Token token) { |
336 listener.beginLiteralString(token); | 358 listener.beginLiteralString(token); |
337 _begin('LiteralString'); | 359 begin('LiteralString'); |
338 } | 360 } |
339 | 361 |
340 @override | 362 @override |
341 void beginLiteralSymbol(Token token) { | 363 void beginLiteralSymbol(Token token) { |
342 listener.beginLiteralSymbol(token); | 364 listener.beginLiteralSymbol(token); |
343 _begin('LiteralSymbol'); | 365 begin('LiteralSymbol'); |
344 } | 366 } |
345 | 367 |
346 @override | 368 @override |
347 void beginMember(Token token) { | 369 void beginMember(Token token) { |
348 listener.beginMember(token); | 370 listener.beginMember(token); |
349 _begin('Member'); | 371 begin('Member'); |
350 } | 372 } |
351 | 373 |
352 @override | 374 @override |
353 void beginMetadata(Token token) { | 375 void beginMetadata(Token token) { |
354 listener.beginMetadata(token); | 376 listener.beginMetadata(token); |
355 _begin('Metadata'); | 377 begin('Metadata'); |
356 } | 378 } |
357 | 379 |
358 @override | 380 @override |
359 void beginMetadataStar(Token token) { | 381 void beginMetadataStar(Token token) { |
360 listener.beginMetadataStar(token); | 382 listener.beginMetadataStar(token); |
361 _begin('MetadataStar'); | 383 begin('MetadataStar'); |
362 } | 384 } |
363 | 385 |
364 @override | 386 @override |
365 void beginMethod(Token token, Token name) { | 387 void beginMethod(Token token, Token name) { |
366 listener.beginMethod(token, name); | 388 listener.beginMethod(token, name); |
367 _begin('Method'); | 389 begin('Method'); |
368 } | 390 } |
369 | 391 |
370 @override | 392 @override |
371 void beginMixinApplication(Token token) { | 393 void beginMixinApplication(Token token) { |
372 listener.beginMixinApplication(token); | 394 listener.beginMixinApplication(token); |
373 _begin('MixinApplication'); | 395 begin('MixinApplication'); |
374 } | 396 } |
375 | 397 |
376 @override | 398 @override |
377 void beginNamedFunctionExpression(Token token) { | 399 void beginNamedFunctionExpression(Token token) { |
378 listener.beginNamedFunctionExpression(token); | 400 listener.beginNamedFunctionExpression(token); |
379 _begin('NamedFunctionExpression'); | 401 begin('NamedFunctionExpression'); |
380 } | 402 } |
381 | 403 |
382 @override | 404 @override |
383 void beginNamedMixinApplication(Token beginToken, Token name) { | 405 void beginNamedMixinApplication(Token beginToken, Token name) { |
384 listener.beginNamedMixinApplication(beginToken, name); | 406 listener.beginNamedMixinApplication(beginToken, name); |
385 _begin('NamedMixinApplication'); | 407 begin('NamedMixinApplication'); |
386 } | 408 } |
387 | 409 |
388 @override | 410 @override |
389 void beginNewExpression(Token token) { | 411 void beginNewExpression(Token token) { |
390 listener.beginNewExpression(token); | 412 listener.beginNewExpression(token); |
391 _begin('NewExpression'); | 413 begin('NewExpression'); |
392 } | 414 } |
393 | 415 |
394 @override | 416 @override |
395 void beginOptionalFormalParameters(Token token) { | 417 void beginOptionalFormalParameters(Token token) { |
396 listener.beginOptionalFormalParameters(token); | 418 listener.beginOptionalFormalParameters(token); |
397 _begin('OptionalFormalParameters'); | 419 begin('OptionalFormalParameters'); |
398 } | 420 } |
399 | 421 |
400 @override | 422 @override |
401 void beginPart(Token token) { | 423 void beginPart(Token token) { |
402 listener.beginPart(token); | 424 listener.beginPart(token); |
403 _begin('Part'); | 425 begin('Part'); |
404 } | 426 } |
405 | 427 |
406 @override | 428 @override |
407 void beginPartOf(Token token) { | 429 void beginPartOf(Token token) { |
408 listener.beginPartOf(token); | 430 listener.beginPartOf(token); |
409 _begin('PartOf'); | 431 begin('PartOf'); |
410 } | 432 } |
411 | 433 |
412 @override | 434 @override |
413 void beginRedirectingFactoryBody(Token token) { | 435 void beginRedirectingFactoryBody(Token token) { |
414 listener.beginRedirectingFactoryBody(token); | 436 listener.beginRedirectingFactoryBody(token); |
415 _begin('RedirectingFactoryBody'); | 437 begin('RedirectingFactoryBody'); |
416 } | 438 } |
417 | 439 |
418 @override | 440 @override |
419 void beginRethrowStatement(Token token) { | 441 void beginRethrowStatement(Token token) { |
420 listener.beginRethrowStatement(token); | 442 listener.beginRethrowStatement(token); |
421 _begin('RethrowStatement'); | 443 begin('RethrowStatement'); |
422 } | 444 } |
423 | 445 |
424 @override | 446 @override |
425 void beginReturnStatement(Token token) { | 447 void beginReturnStatement(Token token) { |
426 listener.beginReturnStatement(token); | 448 listener.beginReturnStatement(token); |
427 _begin('ReturnStatement'); | 449 begin('ReturnStatement'); |
428 } | 450 } |
429 | 451 |
430 @override | 452 @override |
431 void beginShow(Token showKeyword) { | 453 void beginShow(Token showKeyword) { |
432 listener.beginShow(showKeyword); | 454 listener.beginShow(showKeyword); |
433 _begin('Show'); | 455 begin('Show'); |
434 } | 456 } |
435 | 457 |
436 @override | 458 @override |
437 void beginSwitchBlock(Token token) { | 459 void beginSwitchBlock(Token token) { |
438 listener.beginSwitchBlock(token); | 460 listener.beginSwitchBlock(token); |
439 _begin('SwitchBlock'); | 461 begin('SwitchBlock'); |
440 } | 462 } |
441 | 463 |
442 @override | 464 @override |
443 void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) { | 465 void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) { |
444 listener.beginSwitchCase(labelCount, expressionCount, firstToken); | 466 listener.beginSwitchCase(labelCount, expressionCount, firstToken); |
445 _begin('SwitchCase'); | 467 begin('SwitchCase'); |
446 } | 468 } |
447 | 469 |
448 @override | 470 @override |
449 void beginSwitchStatement(Token token) { | 471 void beginSwitchStatement(Token token) { |
450 listener.beginSwitchStatement(token); | 472 listener.beginSwitchStatement(token); |
451 _begin('SwitchStatement'); | 473 begin('SwitchStatement'); |
452 } | 474 } |
453 | 475 |
454 @override | 476 @override |
455 void beginThenStatement(Token token) { | 477 void beginThenStatement(Token token) { |
456 listener.beginThenStatement(token); | 478 listener.beginThenStatement(token); |
457 _begin('ThenStatement'); | 479 begin('ThenStatement'); |
458 } | 480 } |
459 | 481 |
460 @override | 482 @override |
461 void beginTopLevelMember(Token token) { | 483 void beginTopLevelMember(Token token) { |
462 listener.beginTopLevelMember(token); | 484 listener.beginTopLevelMember(token); |
463 _begin('TopLevelMember'); | 485 begin('TopLevelMember'); |
464 } | 486 } |
465 | 487 |
466 @override | 488 @override |
467 void beginTopLevelMethod(Token token, Token name) { | 489 void beginTopLevelMethod(Token token, Token name) { |
468 listener.beginTopLevelMethod(token, name); | 490 listener.beginTopLevelMethod(token, name); |
469 _begin('TopLevelMethod'); | 491 begin('TopLevelMethod'); |
470 } | 492 } |
471 | 493 |
472 @override | 494 @override |
473 void beginTryStatement(Token token) { | 495 void beginTryStatement(Token token) { |
474 listener.beginTryStatement(token); | 496 listener.beginTryStatement(token); |
475 _begin('TryStatement'); | 497 begin('TryStatement'); |
476 } | 498 } |
477 | 499 |
478 @override | 500 @override |
479 void beginTypeArguments(Token token) { | 501 void beginTypeArguments(Token token) { |
480 listener.beginTypeArguments(token); | 502 listener.beginTypeArguments(token); |
481 _begin('TypeArguments'); | 503 begin('TypeArguments'); |
482 } | 504 } |
483 | 505 |
484 @override | 506 @override |
485 void beginTypeList(Token token) { | 507 void beginTypeList(Token token) { |
486 listener.beginTypeList(token); | 508 listener.beginTypeList(token); |
487 _begin('TypeList'); | 509 begin('TypeList'); |
488 } | 510 } |
489 | 511 |
490 @override | 512 @override |
491 void beginTypeVariable(Token token) { | 513 void beginTypeVariable(Token token) { |
492 listener.beginTypeVariable(token); | 514 listener.beginTypeVariable(token); |
493 _begin('TypeVariable'); | 515 begin('TypeVariable'); |
494 } | 516 } |
495 | 517 |
496 @override | 518 @override |
497 void beginTypeVariables(Token token) { | 519 void beginTypeVariables(Token token) { |
498 listener.beginTypeVariables(token); | 520 listener.beginTypeVariables(token); |
499 _begin('TypeVariables'); | 521 begin('TypeVariables'); |
500 } | 522 } |
501 | 523 |
502 @override | 524 @override |
503 void beginVariableInitializer(Token token) { | 525 void beginVariableInitializer(Token token) { |
504 listener.beginVariableInitializer(token); | 526 listener.beginVariableInitializer(token); |
505 _begin('VariableInitializer'); | 527 begin('VariableInitializer'); |
506 } | 528 } |
507 | 529 |
508 @override | 530 @override |
509 void beginVariablesDeclaration(Token token) { | 531 void beginVariablesDeclaration(Token token) { |
510 listener.beginVariablesDeclaration(token); | 532 listener.beginVariablesDeclaration(token); |
511 _begin('VariablesDeclaration'); | 533 begin('VariablesDeclaration'); |
512 } | 534 } |
513 | 535 |
514 @override | 536 @override |
515 void beginWhileStatement(Token token) { | 537 void beginWhileStatement(Token token) { |
516 listener.beginWhileStatement(token); | 538 listener.beginWhileStatement(token); |
517 _begin('WhileStatement'); | 539 begin('WhileStatement'); |
518 } | 540 } |
519 | 541 |
520 @override | 542 @override |
521 void beginWhileStatementBody(Token token) { | 543 void beginWhileStatementBody(Token token) { |
522 listener.beginWhileStatementBody(token); | 544 listener.beginWhileStatementBody(token); |
523 _begin('WhileStatementBody'); | 545 begin('WhileStatementBody'); |
524 } | 546 } |
525 | 547 |
526 @override | 548 @override |
527 void beginYieldStatement(Token token) { | 549 void beginYieldStatement(Token token) { |
528 listener.beginYieldStatement(token); | 550 listener.beginYieldStatement(token); |
529 _begin('YieldStatement'); | 551 begin('YieldStatement'); |
530 } | 552 } |
531 | 553 |
532 @override | 554 @override |
533 void discardTypeReplacedWithCommentTypeAssign() { | 555 void discardTypeReplacedWithCommentTypeAssign() { |
534 listener.discardTypeReplacedWithCommentTypeAssign(); | 556 listener.discardTypeReplacedWithCommentTypeAssign(); |
535 // TODO(danrubel): implement discardTypeReplacedWithCommentTypeAssign | 557 // TODO(danrubel): implement discardTypeReplacedWithCommentTypeAssign |
536 } | 558 } |
537 | 559 |
538 @override | 560 @override |
539 void endArguments(int count, Token beginToken, Token endToken) { | 561 void endArguments(int count, Token beginToken, Token endToken) { |
540 _end('Arguments'); | 562 end('Arguments'); |
541 listener.endArguments(count, beginToken, endToken); | 563 listener.endArguments(count, beginToken, endToken); |
542 } | 564 } |
543 | 565 |
544 @override | 566 @override |
545 void endAssert(Token assertKeyword, fasta.Assert kind, Token leftParenthesis, | 567 void endAssert(Token assertKeyword, fasta.Assert kind, Token leftParenthesis, |
546 Token commaToken, Token rightParenthesis, Token semicolonToken) { | 568 Token commaToken, Token rightParenthesis, Token semicolonToken) { |
547 _end('Assert'); | 569 end('Assert'); |
548 listener.endAssert(assertKeyword, kind, leftParenthesis, commaToken, | 570 listener.endAssert(assertKeyword, kind, leftParenthesis, commaToken, |
549 rightParenthesis, semicolonToken); | 571 rightParenthesis, semicolonToken); |
550 } | 572 } |
551 | 573 |
552 @override | 574 @override |
553 void endAwaitExpression(Token beginToken, Token endToken) { | 575 void endAwaitExpression(Token beginToken, Token endToken) { |
554 _end('AwaitExpression'); | 576 end('AwaitExpression'); |
555 listener.endAwaitExpression(beginToken, endToken); | 577 listener.endAwaitExpression(beginToken, endToken); |
556 } | 578 } |
557 | 579 |
558 @override | 580 @override |
559 void endBlock(int count, Token beginToken, Token endToken) { | 581 void endBlock(int count, Token beginToken, Token endToken) { |
560 _end('Block'); | 582 end('Block'); |
561 listener.endBlock(count, beginToken, endToken); | 583 listener.endBlock(count, beginToken, endToken); |
562 } | 584 } |
563 | 585 |
564 @override | 586 @override |
565 void endBlockFunctionBody(int count, Token beginToken, Token endToken) { | 587 void endBlockFunctionBody(int count, Token beginToken, Token endToken) { |
566 _end('BlockFunctionBody'); | 588 end('BlockFunctionBody'); |
567 listener.endBlockFunctionBody(count, beginToken, endToken); | 589 listener.endBlockFunctionBody(count, beginToken, endToken); |
568 } | 590 } |
569 | 591 |
570 @override | 592 @override |
571 void endCascade() { | 593 void endCascade() { |
572 _end('Cascade'); | 594 end('Cascade'); |
573 listener.endCascade(); | 595 listener.endCascade(); |
574 } | 596 } |
575 | 597 |
576 @override | 598 @override |
577 void endCaseExpression(Token colon) { | 599 void endCaseExpression(Token colon) { |
578 _end('CaseExpression'); | 600 end('CaseExpression'); |
579 listener.endCaseExpression(colon); | 601 listener.endCaseExpression(colon); |
580 } | 602 } |
581 | 603 |
582 @override | 604 @override |
583 void endCatchClause(Token token) { | 605 void endCatchClause(Token token) { |
584 _end('CatchClause'); | 606 end('CatchClause'); |
585 listener.endCatchClause(token); | 607 listener.endCatchClause(token); |
586 } | 608 } |
587 | 609 |
588 @override | 610 @override |
589 void endClassBody(int memberCount, Token beginToken, Token endToken) { | 611 void endClassBody(int memberCount, Token beginToken, Token endToken) { |
590 _end('ClassBody'); | 612 end('ClassBody'); |
591 listener.endClassBody(memberCount, beginToken, endToken); | 613 listener.endClassBody(memberCount, beginToken, endToken); |
592 } | 614 } |
593 | 615 |
594 @override | 616 @override |
595 void endClassDeclaration( | 617 void endClassDeclaration( |
596 int interfacesCount, | 618 int interfacesCount, |
597 Token beginToken, | 619 Token beginToken, |
598 Token classKeyword, | 620 Token classKeyword, |
599 Token extendsKeyword, | 621 Token extendsKeyword, |
600 Token implementsKeyword, | 622 Token implementsKeyword, |
601 Token endToken) { | 623 Token endToken) { |
602 _end('ClassDeclaration'); | 624 end('ClassDeclaration'); |
603 _end('ClassOrNamedMixinApplication'); | 625 end('ClassOrNamedMixinApplication'); |
604 listener.endClassDeclaration(interfacesCount, beginToken, classKeyword, | 626 listener.endClassDeclaration(interfacesCount, beginToken, classKeyword, |
605 extendsKeyword, implementsKeyword, endToken); | 627 extendsKeyword, implementsKeyword, endToken); |
606 } | 628 } |
607 | 629 |
608 @override | 630 @override |
609 void endCombinators(int count) { | 631 void endCombinators(int count) { |
610 _end('Combinators'); | 632 end('Combinators'); |
611 listener.endCombinators(count); | 633 listener.endCombinators(count); |
612 } | 634 } |
613 | 635 |
614 @override | 636 @override |
615 void endCompilationUnit(int count, Token token) { | 637 void endCompilationUnit(int count, Token token) { |
616 _end('CompilationUnit'); | 638 end('CompilationUnit'); |
617 listener.endCompilationUnit(count, token); | 639 listener.endCompilationUnit(count, token); |
| 640 expectEmpty(); |
618 } | 641 } |
619 | 642 |
620 @override | 643 @override |
621 void endConditionalUri(Token ifKeyword, Token equalitySign) { | 644 void endConditionalUri(Token ifKeyword, Token equalitySign) { |
622 _end('ConditionalUri'); | 645 end('ConditionalUri'); |
623 listener.endConditionalUri(ifKeyword, equalitySign); | 646 listener.endConditionalUri(ifKeyword, equalitySign); |
624 } | 647 } |
625 | 648 |
626 @override | 649 @override |
627 void endConditionalUris(int count) { | 650 void endConditionalUris(int count) { |
628 _end('ConditionalUris'); | 651 end('ConditionalUris'); |
629 listener.endConditionalUris(count); | 652 listener.endConditionalUris(count); |
630 } | 653 } |
631 | 654 |
632 @override | 655 @override |
633 void endConstExpression(Token token) { | 656 void endConstExpression(Token token) { |
634 _end('ConstExpression'); | 657 end('ConstExpression'); |
635 listener.endConstExpression(token); | 658 listener.endConstExpression(token); |
636 } | 659 } |
637 | 660 |
638 @override | 661 @override |
639 void endConstLiteral(Token token) { | 662 void endConstLiteral(Token token) { |
640 _end('ConstLiteral'); | 663 end('ConstLiteral'); |
641 listener.endConstLiteral(token); | 664 listener.endConstLiteral(token); |
642 } | 665 } |
643 | 666 |
644 @override | 667 @override |
645 void endConstructorReference( | 668 void endConstructorReference( |
646 Token start, Token periodBeforeName, Token endToken) { | 669 Token start, Token periodBeforeName, Token endToken) { |
647 _end('ConstructorReference'); | 670 end('ConstructorReference'); |
648 listener.endConstructorReference(start, periodBeforeName, endToken); | 671 listener.endConstructorReference(start, periodBeforeName, endToken); |
649 } | 672 } |
650 | 673 |
651 @override | 674 @override |
652 void endDoWhileStatement( | 675 void endDoWhileStatement( |
653 Token doKeyword, Token whileKeyword, Token endToken) { | 676 Token doKeyword, Token whileKeyword, Token endToken) { |
654 _end('DoWhileStatement'); | 677 end('DoWhileStatement'); |
655 listener.endDoWhileStatement(doKeyword, whileKeyword, endToken); | 678 listener.endDoWhileStatement(doKeyword, whileKeyword, endToken); |
656 } | 679 } |
657 | 680 |
658 @override | 681 @override |
659 void endDoWhileStatementBody(Token token) { | 682 void endDoWhileStatementBody(Token token) { |
660 _end('DoWhileStatementBody'); | 683 end('DoWhileStatementBody'); |
661 listener.endDoWhileStatementBody(token); | 684 listener.endDoWhileStatementBody(token); |
662 } | 685 } |
663 | 686 |
664 @override | 687 @override |
665 void endDottedName(int count, Token firstIdentifier) { | 688 void endDottedName(int count, Token firstIdentifier) { |
666 _end('DottedName'); | 689 end('DottedName'); |
667 listener.endDottedName(count, firstIdentifier); | 690 listener.endDottedName(count, firstIdentifier); |
668 } | 691 } |
669 | 692 |
670 @override | 693 @override |
671 void endElseStatement(Token token) { | 694 void endElseStatement(Token token) { |
672 _end('ElseStatement'); | 695 end('ElseStatement'); |
673 listener.endElseStatement(token); | 696 listener.endElseStatement(token); |
674 } | 697 } |
675 | 698 |
676 @override | 699 @override |
677 void endEnum(Token enumKeyword, Token endBrace, int count) { | 700 void endEnum(Token enumKeyword, Token endBrace, int count) { |
678 _end('Enum'); | 701 end('Enum'); |
679 listener.endEnum(enumKeyword, endBrace, count); | 702 listener.endEnum(enumKeyword, endBrace, count); |
680 } | 703 } |
681 | 704 |
682 @override | 705 @override |
683 void endExport(Token exportKeyword, Token semicolon) { | 706 void endExport(Token exportKeyword, Token semicolon) { |
684 _end('Export'); | 707 end('Export'); |
685 listener.endExport(exportKeyword, semicolon); | 708 listener.endExport(exportKeyword, semicolon); |
686 } | 709 } |
687 | 710 |
688 @override | 711 @override |
689 void endExpressionStatement(Token token) { | 712 void endExpressionStatement(Token token) { |
690 _end('ExpressionStatement'); | 713 end('ExpressionStatement'); |
691 listener.endExpressionStatement(token); | 714 listener.endExpressionStatement(token); |
692 } | 715 } |
693 | 716 |
694 @override | 717 @override |
695 void endFactoryMethod( | 718 void endFactoryMethod( |
696 Token beginToken, Token factoryKeyword, Token endToken) { | 719 Token beginToken, Token factoryKeyword, Token endToken) { |
697 _end('FactoryMethod'); | 720 end('FactoryMethod'); |
698 listener.endFactoryMethod(beginToken, factoryKeyword, endToken); | 721 listener.endFactoryMethod(beginToken, factoryKeyword, endToken); |
699 } | 722 } |
700 | 723 |
701 @override | 724 @override |
702 void endFieldInitializer(Token assignment, Token token) { | 725 void endFieldInitializer(Token assignment, Token token) { |
703 _end('FieldInitializer'); | 726 end('FieldInitializer'); |
704 listener.endFieldInitializer(assignment, token); | 727 listener.endFieldInitializer(assignment, token); |
705 } | 728 } |
706 | 729 |
707 @override | 730 @override |
708 void endFields(int count, Token beginToken, Token endToken) { | 731 void endFields(int count, Token beginToken, Token endToken) { |
709 // beginMember --> endFields, endMember | 732 // beginMember --> endFields, endMember |
710 _in('Member'); | 733 expectIn('Member'); |
711 listener.endFields(count, beginToken, endToken); | 734 listener.endFields(count, beginToken, endToken); |
712 } | 735 } |
713 | 736 |
714 @override | 737 @override |
715 void endForIn(Token awaitToken, Token forToken, Token leftParenthesis, | 738 void endForIn(Token awaitToken, Token forToken, Token leftParenthesis, |
716 Token inKeyword, Token rightParenthesis, Token endToken) { | 739 Token inKeyword, Token rightParenthesis, Token endToken) { |
717 _end('ForStatement'); | 740 end('ForStatement'); |
718 listener.endForIn(awaitToken, forToken, leftParenthesis, inKeyword, | 741 listener.endForIn(awaitToken, forToken, leftParenthesis, inKeyword, |
719 rightParenthesis, endToken); | 742 rightParenthesis, endToken); |
720 } | 743 } |
721 | 744 |
722 @override | 745 @override |
723 void endForInBody(Token token) { | 746 void endForInBody(Token token) { |
724 _end('ForInBody'); | 747 end('ForInBody'); |
725 listener.endForInBody(token); | 748 listener.endForInBody(token); |
726 } | 749 } |
727 | 750 |
728 @override | 751 @override |
729 void endForInExpression(Token token) { | 752 void endForInExpression(Token token) { |
730 _end('ForInExpression'); | 753 end('ForInExpression'); |
731 listener.endForInExpression(token); | 754 listener.endForInExpression(token); |
732 } | 755 } |
733 | 756 |
734 @override | 757 @override |
735 void endForStatement(Token forKeyword, Token leftSeparator, | 758 void endForStatement(Token forKeyword, Token leftSeparator, |
736 int updateExpressionCount, Token endToken) { | 759 int updateExpressionCount, Token endToken) { |
737 _end('ForStatement'); | 760 end('ForStatement'); |
738 listener.endForStatement( | 761 listener.endForStatement( |
739 forKeyword, leftSeparator, updateExpressionCount, endToken); | 762 forKeyword, leftSeparator, updateExpressionCount, endToken); |
740 } | 763 } |
741 | 764 |
742 @override | 765 @override |
743 void endForStatementBody(Token token) { | 766 void endForStatementBody(Token token) { |
744 _end('ForStatementBody'); | 767 end('ForStatementBody'); |
745 listener.endForStatementBody(token); | 768 listener.endForStatementBody(token); |
746 } | 769 } |
747 | 770 |
748 @override | 771 @override |
749 void endFormalParameter(Token thisKeyword, Token nameToken, | 772 void endFormalParameter(Token thisKeyword, Token nameToken, |
750 fasta.FormalParameterKind kind, fasta.MemberKind memberKind) { | 773 fasta.FormalParameterKind kind, fasta.MemberKind memberKind) { |
751 _end('FormalParameter'); | 774 end('FormalParameter'); |
752 listener.endFormalParameter(thisKeyword, nameToken, kind, memberKind); | 775 listener.endFormalParameter(thisKeyword, nameToken, kind, memberKind); |
753 } | 776 } |
754 | 777 |
755 @override | 778 @override |
756 void endFormalParameters( | 779 void endFormalParameters( |
757 int count, Token beginToken, Token endToken, fasta.MemberKind kind) { | 780 int count, Token beginToken, Token endToken, fasta.MemberKind kind) { |
758 _end('FormalParameters'); | 781 end('FormalParameters'); |
759 listener.endFormalParameters(count, beginToken, endToken, kind); | 782 listener.endFormalParameters(count, beginToken, endToken, kind); |
760 } | 783 } |
761 | 784 |
762 @override | 785 @override |
763 void endLocalFunctionDeclaration(Token endToken) { | 786 void endLocalFunctionDeclaration(Token endToken) { |
764 _end('LocalFunctionDeclaration'); | 787 end('LocalFunctionDeclaration'); |
765 listener.endLocalFunctionDeclaration(endToken); | 788 listener.endLocalFunctionDeclaration(endToken); |
766 } | 789 } |
767 | 790 |
768 @override | 791 @override |
769 void endFunctionExpression(Token beginToken, Token token) { | 792 void endFunctionExpression(Token beginToken, Token token) { |
770 _end('FunctionExpression'); | 793 end('FunctionExpression'); |
771 listener.endFunctionExpression(beginToken, token); | 794 listener.endFunctionExpression(beginToken, token); |
772 } | 795 } |
773 | 796 |
774 @override | 797 @override |
775 void endFunctionName(Token beginToken, Token token) { | 798 void endFunctionName(Token beginToken, Token token) { |
776 _end('FunctionName'); | 799 end('FunctionName'); |
777 listener.endFunctionName(beginToken, token); | 800 listener.endFunctionName(beginToken, token); |
778 } | 801 } |
779 | 802 |
780 @override | 803 @override |
781 void endFunctionType(Token functionToken, Token endToken) { | 804 void endFunctionType(Token functionToken, Token endToken) { |
782 _end('FunctionType'); | 805 end('FunctionType'); |
783 listener.endFunctionType(functionToken, endToken); | 806 listener.endFunctionType(functionToken, endToken); |
784 } | 807 } |
785 | 808 |
786 @override | 809 @override |
787 void endFunctionTypeAlias( | 810 void endFunctionTypeAlias( |
788 Token typedefKeyword, Token equals, Token endToken) { | 811 Token typedefKeyword, Token equals, Token endToken) { |
789 _end('FunctionTypeAlias'); | 812 end('FunctionTypeAlias'); |
790 listener.endFunctionTypeAlias(typedefKeyword, equals, endToken); | 813 listener.endFunctionTypeAlias(typedefKeyword, equals, endToken); |
791 } | 814 } |
792 | 815 |
793 @override | 816 @override |
794 void endFunctionTypedFormalParameter() { | 817 void endFunctionTypedFormalParameter() { |
795 _end('FunctionTypedFormalParameter'); | 818 end('FunctionTypedFormalParameter'); |
796 listener.endFunctionTypedFormalParameter(); | 819 listener.endFunctionTypedFormalParameter(); |
797 } | 820 } |
798 | 821 |
799 @override | 822 @override |
800 void endHide(Token hideKeyword) { | 823 void endHide(Token hideKeyword) { |
801 _end('Hide'); | 824 end('Hide'); |
802 listener.endHide(hideKeyword); | 825 listener.endHide(hideKeyword); |
803 } | 826 } |
804 | 827 |
805 @override | 828 @override |
806 void endIdentifierList(int count) { | 829 void endIdentifierList(int count) { |
807 _end('IdentifierList'); | 830 end('IdentifierList'); |
808 listener.endIdentifierList(count); | 831 listener.endIdentifierList(count); |
809 } | 832 } |
810 | 833 |
811 @override | 834 @override |
812 void endIfStatement(Token ifToken, Token elseToken) { | 835 void endIfStatement(Token ifToken, Token elseToken) { |
813 _end('IfStatement'); | 836 end('IfStatement'); |
814 listener.endIfStatement(ifToken, elseToken); | 837 listener.endIfStatement(ifToken, elseToken); |
815 } | 838 } |
816 | 839 |
817 @override | 840 @override |
818 void endImport(Token importKeyword, Token DeferredKeyword, Token asKeyword, | 841 void endImport(Token importKeyword, Token DeferredKeyword, Token asKeyword, |
819 Token semicolon) { | 842 Token semicolon) { |
820 _end('Import'); | 843 end('Import'); |
821 listener.endImport(importKeyword, DeferredKeyword, asKeyword, semicolon); | 844 listener.endImport(importKeyword, DeferredKeyword, asKeyword, semicolon); |
822 } | 845 } |
823 | 846 |
824 @override | 847 @override |
825 void endInitializedIdentifier(Token nameToken) { | 848 void endInitializedIdentifier(Token nameToken) { |
826 _end('InitializedIdentifier'); | 849 end('InitializedIdentifier'); |
827 listener.endInitializedIdentifier(nameToken); | 850 listener.endInitializedIdentifier(nameToken); |
828 } | 851 } |
829 | 852 |
830 @override | 853 @override |
831 void endInitializer(Token token) { | 854 void endInitializer(Token token) { |
832 _end('Initializer'); | 855 end('Initializer'); |
833 listener.endInitializer(token); | 856 listener.endInitializer(token); |
834 } | 857 } |
835 | 858 |
836 @override | 859 @override |
837 void endInitializers(int count, Token beginToken, Token endToken) { | 860 void endInitializers(int count, Token beginToken, Token endToken) { |
838 _end('Initializers'); | 861 end('Initializers'); |
839 listener.endInitializers(count, beginToken, endToken); | 862 listener.endInitializers(count, beginToken, endToken); |
840 } | 863 } |
841 | 864 |
842 @override | 865 @override |
843 void endLabeledStatement(int labelCount) { | 866 void endLabeledStatement(int labelCount) { |
844 _end('LabeledStatement'); | 867 end('LabeledStatement'); |
845 listener.endLabeledStatement(labelCount); | 868 listener.endLabeledStatement(labelCount); |
846 } | 869 } |
847 | 870 |
848 @override | 871 @override |
849 void endLibraryName(Token libraryKeyword, Token semicolon) { | 872 void endLibraryName(Token libraryKeyword, Token semicolon) { |
850 _end('LibraryName'); | 873 end('LibraryName'); |
851 listener.endLibraryName(libraryKeyword, semicolon); | 874 listener.endLibraryName(libraryKeyword, semicolon); |
852 } | 875 } |
853 | 876 |
854 @override | 877 @override |
855 void endLiteralMapEntry(Token colon, Token endToken) { | 878 void endLiteralMapEntry(Token colon, Token endToken) { |
856 _end('LiteralMapEntry'); | 879 end('LiteralMapEntry'); |
857 listener.endLiteralMapEntry(colon, endToken); | 880 listener.endLiteralMapEntry(colon, endToken); |
858 } | 881 } |
859 | 882 |
860 @override | 883 @override |
861 void endLiteralString(int interpolationCount, Token endToken) { | 884 void endLiteralString(int interpolationCount, Token endToken) { |
862 _end('LiteralString'); | 885 end('LiteralString'); |
863 listener.endLiteralString(interpolationCount, endToken); | 886 listener.endLiteralString(interpolationCount, endToken); |
864 } | 887 } |
865 | 888 |
866 @override | 889 @override |
867 void endLiteralSymbol(Token hashToken, int identifierCount) { | 890 void endLiteralSymbol(Token hashToken, int identifierCount) { |
868 _end('LiteralSymbol'); | 891 end('LiteralSymbol'); |
869 listener.endLiteralSymbol(hashToken, identifierCount); | 892 listener.endLiteralSymbol(hashToken, identifierCount); |
870 } | 893 } |
871 | 894 |
872 @override | 895 @override |
873 void endMember() { | 896 void endMember() { |
874 _end('Member'); | 897 end('Member'); |
875 listener.endMember(); | 898 listener.endMember(); |
876 } | 899 } |
877 | 900 |
878 @override | 901 @override |
879 void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) { | 902 void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) { |
880 _end('Metadata'); | 903 end('Metadata'); |
881 listener.endMetadata(beginToken, periodBeforeName, endToken); | 904 listener.endMetadata(beginToken, periodBeforeName, endToken); |
882 } | 905 } |
883 | 906 |
884 @override | 907 @override |
885 void endMetadataStar(int count, bool forParameter) { | 908 void endMetadataStar(int count, bool forParameter) { |
886 _end('MetadataStar'); | 909 end('MetadataStar'); |
887 listener.endMetadataStar(count, forParameter); | 910 listener.endMetadataStar(count, forParameter); |
888 } | 911 } |
889 | 912 |
890 @override | 913 @override |
891 void endMethod(Token getOrSet, Token beginToken, Token endToken) { | 914 void endMethod(Token getOrSet, Token beginToken, Token endToken) { |
892 _end('Method'); | 915 end('Method'); |
893 listener.endMethod(getOrSet, beginToken, endToken); | 916 listener.endMethod(getOrSet, beginToken, endToken); |
894 } | 917 } |
895 | 918 |
896 @override | 919 @override |
897 void endMixinApplication(Token withKeyword) { | 920 void endMixinApplication(Token withKeyword) { |
898 _end('MixinApplication'); | 921 end('MixinApplication'); |
899 listener.endMixinApplication(withKeyword); | 922 listener.endMixinApplication(withKeyword); |
900 } | 923 } |
901 | 924 |
902 @override | 925 @override |
903 void endNamedFunctionExpression(Token endToken) { | 926 void endNamedFunctionExpression(Token endToken) { |
904 _end('NamedFunctionExpression'); | 927 end('NamedFunctionExpression'); |
905 listener.endNamedFunctionExpression(endToken); | 928 listener.endNamedFunctionExpression(endToken); |
906 } | 929 } |
907 | 930 |
908 @override | 931 @override |
909 void endNamedMixinApplication(Token begin, Token classKeyword, Token equals, | 932 void endNamedMixinApplication(Token begin, Token classKeyword, Token equals, |
910 Token implementsKeyword, Token endToken) { | 933 Token implementsKeyword, Token endToken) { |
911 _end('NamedMixinApplication'); | 934 end('NamedMixinApplication'); |
912 _end('ClassOrNamedMixinApplication'); | 935 end('ClassOrNamedMixinApplication'); |
913 listener.endNamedMixinApplication( | 936 listener.endNamedMixinApplication( |
914 begin, classKeyword, equals, implementsKeyword, endToken); | 937 begin, classKeyword, equals, implementsKeyword, endToken); |
915 } | 938 } |
916 | 939 |
917 @override | 940 @override |
918 void endNewExpression(Token token) { | 941 void endNewExpression(Token token) { |
919 _end('NewExpression'); | 942 end('NewExpression'); |
920 listener.endNewExpression(token); | 943 listener.endNewExpression(token); |
921 } | 944 } |
922 | 945 |
923 @override | 946 @override |
924 void endOptionalFormalParameters( | 947 void endOptionalFormalParameters( |
925 int count, Token beginToken, Token endToken) { | 948 int count, Token beginToken, Token endToken) { |
926 _end('OptionalFormalParameters'); | 949 end('OptionalFormalParameters'); |
927 listener.endOptionalFormalParameters(count, beginToken, endToken); | 950 listener.endOptionalFormalParameters(count, beginToken, endToken); |
928 } | 951 } |
929 | 952 |
930 @override | 953 @override |
931 void endPart(Token partKeyword, Token semicolon) { | 954 void endPart(Token partKeyword, Token semicolon) { |
932 _end('Part'); | 955 end('Part'); |
933 listener.endPart(partKeyword, semicolon); | 956 listener.endPart(partKeyword, semicolon); |
934 } | 957 } |
935 | 958 |
936 @override | 959 @override |
937 void endPartOf(Token partKeyword, Token semicolon, bool hasName) { | 960 void endPartOf(Token partKeyword, Token semicolon, bool hasName) { |
938 _end('PartOf'); | 961 end('PartOf'); |
939 listener.endPartOf(partKeyword, semicolon, hasName); | 962 listener.endPartOf(partKeyword, semicolon, hasName); |
940 } | 963 } |
941 | 964 |
942 @override | 965 @override |
943 void endRedirectingFactoryBody(Token beginToken, Token endToken) { | 966 void endRedirectingFactoryBody(Token beginToken, Token endToken) { |
944 _end('RedirectingFactoryBody'); | 967 end('RedirectingFactoryBody'); |
945 listener.endRedirectingFactoryBody(beginToken, endToken); | 968 listener.endRedirectingFactoryBody(beginToken, endToken); |
946 } | 969 } |
947 | 970 |
948 @override | 971 @override |
949 void endRethrowStatement(Token rethrowToken, Token endToken) { | 972 void endRethrowStatement(Token rethrowToken, Token endToken) { |
950 _end('RethrowStatement'); | 973 end('RethrowStatement'); |
951 listener.endRethrowStatement(rethrowToken, endToken); | 974 listener.endRethrowStatement(rethrowToken, endToken); |
952 } | 975 } |
953 | 976 |
954 @override | 977 @override |
955 void endReturnStatement( | 978 void endReturnStatement( |
956 bool hasExpression, Token beginToken, Token endToken) { | 979 bool hasExpression, Token beginToken, Token endToken) { |
957 _end('ReturnStatement'); | 980 end('ReturnStatement'); |
958 listener.endReturnStatement(hasExpression, beginToken, endToken); | 981 listener.endReturnStatement(hasExpression, beginToken, endToken); |
959 } | 982 } |
960 | 983 |
961 @override | 984 @override |
962 void endShow(Token showKeyword) { | 985 void endShow(Token showKeyword) { |
963 _end('Show'); | 986 end('Show'); |
964 listener.endShow(showKeyword); | 987 listener.endShow(showKeyword); |
965 } | 988 } |
966 | 989 |
967 @override | 990 @override |
968 void endSwitchBlock(int caseCount, Token beginToken, Token endToken) { | 991 void endSwitchBlock(int caseCount, Token beginToken, Token endToken) { |
969 _end('SwitchBlock'); | 992 end('SwitchBlock'); |
970 listener.endSwitchBlock(caseCount, beginToken, endToken); | 993 listener.endSwitchBlock(caseCount, beginToken, endToken); |
971 } | 994 } |
972 | 995 |
973 @override | 996 @override |
974 void endSwitchCase(int labelCount, int expressionCount, Token defaultKeyword, | 997 void endSwitchCase(int labelCount, int expressionCount, Token defaultKeyword, |
975 int statementCount, Token firstToken, Token endToken) { | 998 int statementCount, Token firstToken, Token endToken) { |
976 _end('SwitchCase'); | 999 end('SwitchCase'); |
977 listener.endSwitchCase(labelCount, expressionCount, defaultKeyword, | 1000 listener.endSwitchCase(labelCount, expressionCount, defaultKeyword, |
978 statementCount, firstToken, endToken); | 1001 statementCount, firstToken, endToken); |
979 } | 1002 } |
980 | 1003 |
981 @override | 1004 @override |
982 void endSwitchStatement(Token switchKeyword, Token endToken) { | 1005 void endSwitchStatement(Token switchKeyword, Token endToken) { |
983 _end('SwitchStatement'); | 1006 end('SwitchStatement'); |
984 listener.endSwitchStatement(switchKeyword, endToken); | 1007 listener.endSwitchStatement(switchKeyword, endToken); |
985 } | 1008 } |
986 | 1009 |
987 @override | 1010 @override |
988 void endThenStatement(Token token) { | 1011 void endThenStatement(Token token) { |
989 _end('ThenStatement'); | 1012 end('ThenStatement'); |
990 listener.endThenStatement(token); | 1013 listener.endThenStatement(token); |
991 } | 1014 } |
992 | 1015 |
993 @override | 1016 @override |
994 void endTopLevelDeclaration(Token token) { | 1017 void endTopLevelDeclaration(Token token) { |
995 // There is no corresponding beginTopLevelDeclaration | 1018 // There is no corresponding beginTopLevelDeclaration |
996 //_expectBegin('TopLevelDeclaration'); | 1019 //_expectBegin('TopLevelDeclaration'); |
| 1020 expectIn('CompilationUnit'); |
997 listener.endTopLevelDeclaration(token); | 1021 listener.endTopLevelDeclaration(token); |
998 } | 1022 } |
999 | 1023 |
1000 @override | 1024 @override |
1001 void endTopLevelFields(int count, Token beginToken, Token endToken) { | 1025 void endTopLevelFields(int count, Token beginToken, Token endToken) { |
1002 _end('TopLevelMember'); | 1026 end('TopLevelMember'); |
1003 listener.endTopLevelFields(count, beginToken, endToken); | 1027 listener.endTopLevelFields(count, beginToken, endToken); |
1004 } | 1028 } |
1005 | 1029 |
1006 @override | 1030 @override |
1007 void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) { | 1031 void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) { |
1008 _end('TopLevelMethod'); | 1032 end('TopLevelMethod'); |
1009 _end('TopLevelMember'); | 1033 end('TopLevelMember'); |
1010 listener.endTopLevelMethod(beginToken, getOrSet, endToken); | 1034 listener.endTopLevelMethod(beginToken, getOrSet, endToken); |
1011 } | 1035 } |
1012 | 1036 |
1013 @override | 1037 @override |
1014 void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) { | 1038 void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) { |
1015 _end('TryStatement'); | 1039 end('TryStatement'); |
1016 listener.endTryStatement(catchCount, tryKeyword, finallyKeyword); | 1040 listener.endTryStatement(catchCount, tryKeyword, finallyKeyword); |
1017 } | 1041 } |
1018 | 1042 |
1019 @override | 1043 @override |
1020 void endTypeArguments(int count, Token beginToken, Token endToken) { | 1044 void endTypeArguments(int count, Token beginToken, Token endToken) { |
1021 _end('TypeArguments'); | 1045 end('TypeArguments'); |
1022 listener.endTypeArguments(count, beginToken, endToken); | 1046 listener.endTypeArguments(count, beginToken, endToken); |
1023 } | 1047 } |
1024 | 1048 |
1025 @override | 1049 @override |
1026 void endTypeList(int count) { | 1050 void endTypeList(int count) { |
1027 _end('TypeList'); | 1051 end('TypeList'); |
1028 listener.endTypeList(count); | 1052 listener.endTypeList(count); |
1029 } | 1053 } |
1030 | 1054 |
1031 @override | 1055 @override |
1032 void endTypeVariable(Token token, Token extendsOrSuper) { | 1056 void endTypeVariable(Token token, Token extendsOrSuper) { |
1033 _end('TypeVariable'); | 1057 end('TypeVariable'); |
1034 listener.endTypeVariable(token, extendsOrSuper); | 1058 listener.endTypeVariable(token, extendsOrSuper); |
1035 } | 1059 } |
1036 | 1060 |
1037 @override | 1061 @override |
1038 void endTypeVariables(int count, Token beginToken, Token endToken) { | 1062 void endTypeVariables(int count, Token beginToken, Token endToken) { |
1039 _end('TypeVariables'); | 1063 end('TypeVariables'); |
1040 listener.endTypeVariables(count, beginToken, endToken); | 1064 listener.endTypeVariables(count, beginToken, endToken); |
1041 } | 1065 } |
1042 | 1066 |
1043 @override | 1067 @override |
1044 void endVariableInitializer(Token assignmentOperator) { | 1068 void endVariableInitializer(Token assignmentOperator) { |
1045 _end('VariableInitializer'); | 1069 end('VariableInitializer'); |
1046 listener.endVariableInitializer(assignmentOperator); | 1070 listener.endVariableInitializer(assignmentOperator); |
1047 } | 1071 } |
1048 | 1072 |
1049 @override | 1073 @override |
1050 void endVariablesDeclaration(int count, Token endToken) { | 1074 void endVariablesDeclaration(int count, Token endToken) { |
1051 _end('VariablesDeclaration'); | 1075 end('VariablesDeclaration'); |
1052 listener.endVariablesDeclaration(count, endToken); | 1076 listener.endVariablesDeclaration(count, endToken); |
1053 } | 1077 } |
1054 | 1078 |
1055 @override | 1079 @override |
1056 void endWhileStatement(Token whileKeyword, Token endToken) { | 1080 void endWhileStatement(Token whileKeyword, Token endToken) { |
1057 _end('WhileStatement'); | 1081 end('WhileStatement'); |
1058 listener.endWhileStatement(whileKeyword, endToken); | 1082 listener.endWhileStatement(whileKeyword, endToken); |
1059 } | 1083 } |
1060 | 1084 |
1061 @override | 1085 @override |
1062 void endWhileStatementBody(Token token) { | 1086 void endWhileStatementBody(Token token) { |
1063 _end('WhileStatementBody'); | 1087 end('WhileStatementBody'); |
1064 listener.endWhileStatementBody(token); | 1088 listener.endWhileStatementBody(token); |
1065 } | 1089 } |
1066 | 1090 |
1067 @override | 1091 @override |
1068 void endYieldStatement(Token yieldToken, Token starToken, Token endToken) { | 1092 void endYieldStatement(Token yieldToken, Token starToken, Token endToken) { |
1069 _end('YieldStatement'); | 1093 end('YieldStatement'); |
1070 listener.endYieldStatement(yieldToken, starToken, endToken); | 1094 listener.endYieldStatement(yieldToken, starToken, endToken); |
1071 } | 1095 } |
1072 | 1096 |
1073 @override | 1097 @override |
1074 void handleAsOperator(Token operator, Token endToken) { | 1098 void handleAsOperator(Token operator, Token endToken) { |
1075 listener.handleAsOperator(operator, endToken); | 1099 listener.handleAsOperator(operator, endToken); |
1076 // TODO(danrubel): implement handleAsOperator | 1100 // TODO(danrubel): implement handleAsOperator |
1077 } | 1101 } |
1078 | 1102 |
1079 @override | 1103 @override |
(...skipping 430 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1510 @override | 1534 @override |
1511 set suppressParseErrors(bool value) { | 1535 set suppressParseErrors(bool value) { |
1512 listener.suppressParseErrors = value; | 1536 listener.suppressParseErrors = value; |
1513 // TODO(danrubel): implement suppressParseErrors | 1537 // TODO(danrubel): implement suppressParseErrors |
1514 } | 1538 } |
1515 | 1539 |
1516 // TODO(danrubel): implement uri | 1540 // TODO(danrubel): implement uri |
1517 @override | 1541 @override |
1518 Uri get uri => listener.uri; | 1542 Uri get uri => listener.uri; |
1519 } | 1543 } |
OLD | NEW |