]>
Commit | Line | Data |
---|---|---|
1b2798f6 EK |
1 | /******************************************************************************* |
2 | * Copyright (c) 2000, 2011 IBM Corporation and others. | |
3 | * All rights reserved. This program and the accompanying materials | |
4 | * are made available under the terms of the Eclipse Public License v1.0 | |
5 | * which accompanies this distribution, and is available at | |
6 | * http://www.eclipse.org/legal/epl-v10.html | |
7 | * | |
8 | * Contributors: | |
9 | * IBM Corporation - initial API and implementation | |
10 | *******************************************************************************/ | |
11 | package org.eclipse.jdt.internal.corext.dom; | |
12 | ||
13 | import org.eclipse.jdt.core.dom.ASTNode; | |
14 | import org.eclipse.jdt.core.dom.ASTVisitor; | |
15 | import org.eclipse.jdt.core.dom.AbstractTypeDeclaration; | |
16 | import org.eclipse.jdt.core.dom.Annotation; | |
17 | import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration; | |
18 | import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration; | |
19 | import org.eclipse.jdt.core.dom.AnonymousClassDeclaration; | |
20 | import org.eclipse.jdt.core.dom.ArrayAccess; | |
21 | import org.eclipse.jdt.core.dom.ArrayCreation; | |
22 | import org.eclipse.jdt.core.dom.ArrayInitializer; | |
23 | import org.eclipse.jdt.core.dom.ArrayType; | |
24 | import org.eclipse.jdt.core.dom.AssertStatement; | |
25 | import org.eclipse.jdt.core.dom.Assignment; | |
26 | import org.eclipse.jdt.core.dom.Block; | |
27 | import org.eclipse.jdt.core.dom.BlockComment; | |
28 | import org.eclipse.jdt.core.dom.BodyDeclaration; | |
29 | import org.eclipse.jdt.core.dom.BooleanLiteral; | |
30 | import org.eclipse.jdt.core.dom.BreakStatement; | |
31 | import org.eclipse.jdt.core.dom.CastExpression; | |
32 | import org.eclipse.jdt.core.dom.CatchClause; | |
33 | import org.eclipse.jdt.core.dom.CharacterLiteral; | |
34 | import org.eclipse.jdt.core.dom.ClassInstanceCreation; | |
35 | import org.eclipse.jdt.core.dom.Comment; | |
36 | import org.eclipse.jdt.core.dom.CompilationUnit; | |
37 | import org.eclipse.jdt.core.dom.ConditionalExpression; | |
38 | import org.eclipse.jdt.core.dom.ConstructorInvocation; | |
39 | import org.eclipse.jdt.core.dom.ContinueStatement; | |
40 | import org.eclipse.jdt.core.dom.DoStatement; | |
41 | import org.eclipse.jdt.core.dom.EmptyStatement; | |
42 | import org.eclipse.jdt.core.dom.EnhancedForStatement; | |
43 | import org.eclipse.jdt.core.dom.EnumConstantDeclaration; | |
44 | import org.eclipse.jdt.core.dom.EnumDeclaration; | |
45 | import org.eclipse.jdt.core.dom.Expression; | |
46 | import org.eclipse.jdt.core.dom.ExpressionStatement; | |
47 | import org.eclipse.jdt.core.dom.FieldAccess; | |
48 | import org.eclipse.jdt.core.dom.FieldDeclaration; | |
49 | import org.eclipse.jdt.core.dom.ForStatement; | |
50 | import org.eclipse.jdt.core.dom.IfStatement; | |
51 | import org.eclipse.jdt.core.dom.ImportDeclaration; | |
52 | import org.eclipse.jdt.core.dom.InfixExpression; | |
53 | import org.eclipse.jdt.core.dom.Initializer; | |
54 | import org.eclipse.jdt.core.dom.InstanceofExpression; | |
55 | import org.eclipse.jdt.core.dom.Javadoc; | |
56 | import org.eclipse.jdt.core.dom.LabeledStatement; | |
57 | import org.eclipse.jdt.core.dom.LineComment; | |
58 | import org.eclipse.jdt.core.dom.MarkerAnnotation; | |
59 | import org.eclipse.jdt.core.dom.MemberRef; | |
60 | import org.eclipse.jdt.core.dom.MemberValuePair; | |
61 | import org.eclipse.jdt.core.dom.MethodDeclaration; | |
62 | import org.eclipse.jdt.core.dom.MethodInvocation; | |
63 | import org.eclipse.jdt.core.dom.MethodRef; | |
64 | import org.eclipse.jdt.core.dom.MethodRefParameter; | |
65 | import org.eclipse.jdt.core.dom.Modifier; | |
66 | import org.eclipse.jdt.core.dom.Name; | |
67 | import org.eclipse.jdt.core.dom.NormalAnnotation; | |
68 | import org.eclipse.jdt.core.dom.NullLiteral; | |
69 | import org.eclipse.jdt.core.dom.NumberLiteral; | |
70 | import org.eclipse.jdt.core.dom.PackageDeclaration; | |
71 | import org.eclipse.jdt.core.dom.ParameterizedType; | |
72 | import org.eclipse.jdt.core.dom.ParenthesizedExpression; | |
73 | import org.eclipse.jdt.core.dom.PostfixExpression; | |
74 | import org.eclipse.jdt.core.dom.PrefixExpression; | |
75 | import org.eclipse.jdt.core.dom.PrimitiveType; | |
76 | import org.eclipse.jdt.core.dom.QualifiedName; | |
77 | import org.eclipse.jdt.core.dom.QualifiedType; | |
78 | import org.eclipse.jdt.core.dom.ReturnStatement; | |
79 | import org.eclipse.jdt.core.dom.SimpleName; | |
80 | import org.eclipse.jdt.core.dom.SimpleType; | |
81 | import org.eclipse.jdt.core.dom.SingleMemberAnnotation; | |
82 | import org.eclipse.jdt.core.dom.SingleVariableDeclaration; | |
83 | import org.eclipse.jdt.core.dom.Statement; | |
84 | import org.eclipse.jdt.core.dom.StringLiteral; | |
85 | import org.eclipse.jdt.core.dom.SuperConstructorInvocation; | |
86 | import org.eclipse.jdt.core.dom.SuperFieldAccess; | |
87 | import org.eclipse.jdt.core.dom.SuperMethodInvocation; | |
88 | import org.eclipse.jdt.core.dom.SwitchCase; | |
89 | import org.eclipse.jdt.core.dom.SwitchStatement; | |
90 | import org.eclipse.jdt.core.dom.SynchronizedStatement; | |
91 | import org.eclipse.jdt.core.dom.TagElement; | |
92 | import org.eclipse.jdt.core.dom.TextElement; | |
93 | import org.eclipse.jdt.core.dom.ThisExpression; | |
94 | import org.eclipse.jdt.core.dom.ThrowStatement; | |
95 | import org.eclipse.jdt.core.dom.TryStatement; | |
96 | import org.eclipse.jdt.core.dom.Type; | |
97 | import org.eclipse.jdt.core.dom.TypeDeclaration; | |
98 | import org.eclipse.jdt.core.dom.TypeDeclarationStatement; | |
99 | import org.eclipse.jdt.core.dom.TypeLiteral; | |
100 | import org.eclipse.jdt.core.dom.TypeParameter; | |
101 | import org.eclipse.jdt.core.dom.UnionType; | |
102 | import org.eclipse.jdt.core.dom.VariableDeclaration; | |
103 | import org.eclipse.jdt.core.dom.VariableDeclarationExpression; | |
104 | import org.eclipse.jdt.core.dom.VariableDeclarationFragment; | |
105 | import org.eclipse.jdt.core.dom.VariableDeclarationStatement; | |
106 | import org.eclipse.jdt.core.dom.WhileStatement; | |
107 | import org.eclipse.jdt.core.dom.WildcardType; | |
108 | ||
109 | /** | |
110 | * <p> | |
111 | * This class provides a convenient behaviour-only extension mechanism for the ASTNode hierarchy. If | |
112 | * you feel like you would like to add a method to the ASTNode hierarchy (or a subtree of the | |
113 | * hierarchy), and you want to have different implementations of it at different points in the | |
114 | * hierarchy, simply create a HierarchicalASTVisitor representing the new method and all its | |
115 | * implementations, locating each implementation within the right visit(XX) method. If you wanted to | |
116 | * add a method implementation to abstract class Foo, an ASTNode descendant, put your implementation | |
117 | * in visit(Foo). This class will provide appropriate dispatch, just as if the method | |
118 | * implementations had been added to the ASTNode hierarchy. | |
119 | * </p> | |
120 | * | |
121 | * <p> | |
122 | * <b>Details:<b> | |
123 | * </p> | |
124 | * | |
125 | * <p> | |
126 | * This class has a visit(XX node) method for every class (concrete or abstract) XX in the ASTNode | |
127 | * hierarchy. In this class' default implementations of these methods, the method corresponding to a | |
128 | * given ASTNode descendant class will call (and return the return value of) the visit(YY) method | |
129 | * for it's superclass YY, with the exception of the visit(ASTNode) method which simply returns | |
130 | * true, since ASTNode doesn't have a superclass that is within the ASTNode hierarchy. | |
131 | * </p> | |
132 | * | |
133 | * <p> | |
134 | * Because of this organization, when visit(XX) methods are overridden in a subclass, and the | |
135 | * visitor is applied to a node, only the most specialized overridden method implementation for the | |
136 | * node's type will be called, unless this most specialized method calls other visit methods (this | |
137 | * is discouraged) or, (preferably) calls super.visit(XX node), (the reference type of the parameter | |
138 | * must be XX) which will invoke this class' implementation of the method, which will, in turn, | |
139 | * invoke the visit(YY) method corresponding to the superclass, YY. | |
140 | * </p> | |
141 | * | |
142 | * <p> | |
143 | * Thus, the dispatching behaviour achieved when HierarchicalASTVisitors' visit(XX) methods, | |
144 | * corresponding to a particular concrete or abstract ASTNode descendant class, are overridden is | |
145 | * exactly analogous to the dispatching behaviour obtained when method implementations are added to | |
146 | * the same ASTNode descendant classes. | |
147 | * </p> | |
148 | */ | |
149 | /* | |
150 | * IMPORTANT NOTE: | |
151 | * | |
152 | * The structure and behaviour of this class is | |
153 | * verified reflectively by | |
154 | * org.eclipse.jdt.ui.tests.core.HierarchicalASTVisitorTest | |
155 | * | |
156 | */ | |
157 | public abstract class HierarchicalASTVisitor extends ASTVisitor { | |
158 | //TODO: check callers for handling of comments | |
159 | ||
160 | //---- Begin ASTNode Hierarchy ------------------------------------- | |
161 | ||
162 | /** | |
163 | * Visits the given AST node. | |
164 | * <p> | |
165 | * The default implementation does nothing and return true. Subclasses may reimplement. | |
166 | * </p> | |
167 | * | |
168 | * @param node the node to visit | |
169 | * @return <code>true</code> if the children of this node should be visited, and | |
170 | * <code>false</code> if the children of this node should be skipped | |
171 | */ | |
172 | public boolean visit(ASTNode node) { | |
173 | return true; | |
174 | } | |
175 | ||
176 | /** | |
177 | * End of visit the given AST node. | |
178 | * <p> | |
179 | * The default implementation does nothing. Subclasses may reimplement. | |
180 | * </p> | |
181 | * | |
182 | * @param node the node to visit | |
183 | */ | |
184 | public void endVisit(ASTNode node) { | |
185 | // do nothing | |
186 | } | |
187 | ||
188 | @Override | |
189 | public boolean visit(AnonymousClassDeclaration node) { | |
190 | return visit((ASTNode)node); | |
191 | } | |
192 | ||
193 | @Override | |
194 | public void endVisit(AnonymousClassDeclaration node) { | |
195 | endVisit((ASTNode)node); | |
196 | } | |
197 | ||
198 | //---- Begin BodyDeclaration Hierarchy --------------------------- | |
199 | public boolean visit(BodyDeclaration node) { | |
200 | return visit((ASTNode)node); | |
201 | } | |
202 | ||
203 | public void endVisit(BodyDeclaration node) { | |
204 | endVisit((ASTNode)node); | |
205 | } | |
206 | ||
207 | //---- Begin AbstractTypeDeclaration Hierarchy --------------------------- | |
208 | public boolean visit(AbstractTypeDeclaration node) { | |
209 | return visit((BodyDeclaration)node); | |
210 | } | |
211 | ||
212 | public void endVisit(AbstractTypeDeclaration node) { | |
213 | endVisit((BodyDeclaration)node); | |
214 | } | |
215 | ||
216 | @Override | |
217 | public boolean visit(AnnotationTypeDeclaration node) { | |
218 | return visit((AbstractTypeDeclaration)node); | |
219 | } | |
220 | ||
221 | @Override | |
222 | public void endVisit(AnnotationTypeDeclaration node) { | |
223 | endVisit((AbstractTypeDeclaration)node); | |
224 | } | |
225 | ||
226 | @Override | |
227 | public boolean visit(EnumDeclaration node) { | |
228 | return visit((AbstractTypeDeclaration)node); | |
229 | } | |
230 | ||
231 | @Override | |
232 | public void endVisit(EnumDeclaration node) { | |
233 | endVisit((AbstractTypeDeclaration)node); | |
234 | } | |
235 | ||
236 | @Override | |
237 | public boolean visit(TypeDeclaration node) { | |
238 | return visit((AbstractTypeDeclaration)node); | |
239 | } | |
240 | ||
241 | @Override | |
242 | public void endVisit(TypeDeclaration node) { | |
243 | endVisit((AbstractTypeDeclaration)node); | |
244 | } | |
245 | ||
246 | //---- End AbstractTypeDeclaration Hierarchy --------------------------- | |
247 | ||
248 | @Override | |
249 | public boolean visit(AnnotationTypeMemberDeclaration node) { | |
250 | return visit((BodyDeclaration)node); | |
251 | } | |
252 | ||
253 | @Override | |
254 | public void endVisit(AnnotationTypeMemberDeclaration node) { | |
255 | endVisit((BodyDeclaration)node); | |
256 | } | |
257 | ||
258 | @Override | |
259 | public boolean visit(EnumConstantDeclaration node) { | |
260 | return visit((BodyDeclaration)node); | |
261 | } | |
262 | ||
263 | @Override | |
264 | public void endVisit(EnumConstantDeclaration node) { | |
265 | endVisit((BodyDeclaration)node); | |
266 | } | |
267 | ||
268 | @Override | |
269 | public boolean visit(FieldDeclaration node) { | |
270 | return visit((BodyDeclaration)node); | |
271 | } | |
272 | ||
273 | @Override | |
274 | public void endVisit(FieldDeclaration node) { | |
275 | endVisit((BodyDeclaration)node); | |
276 | } | |
277 | ||
278 | @Override | |
279 | public boolean visit(Initializer node) { | |
280 | return visit((BodyDeclaration)node); | |
281 | } | |
282 | ||
283 | @Override | |
284 | public void endVisit(Initializer node) { | |
285 | endVisit((BodyDeclaration)node); | |
286 | } | |
287 | ||
288 | @Override | |
289 | public boolean visit(MethodDeclaration node) { | |
290 | return visit((BodyDeclaration)node); | |
291 | } | |
292 | ||
293 | @Override | |
294 | public void endVisit(MethodDeclaration node) { | |
295 | endVisit((BodyDeclaration)node); | |
296 | } | |
297 | ||
298 | //---- End BodyDeclaration Hierarchy ----------------------------- | |
299 | ||
300 | @Override | |
301 | public boolean visit(CatchClause node) { | |
302 | return visit((ASTNode)node); | |
303 | } | |
304 | ||
305 | @Override | |
306 | public void endVisit(CatchClause node) { | |
307 | endVisit((ASTNode)node); | |
308 | } | |
309 | ||
310 | //---- Begin Comment Hierarchy ---------------------------------- | |
311 | public boolean visit(Comment node) { | |
312 | return visit((ASTNode)node); | |
313 | } | |
314 | ||
315 | public void endVisit(Comment node) { | |
316 | endVisit((ASTNode)node); | |
317 | } | |
318 | ||
319 | @Override | |
320 | public boolean visit(BlockComment node) { | |
321 | return visit((Comment)node); | |
322 | } | |
323 | ||
324 | @Override | |
325 | public void endVisit(BlockComment node) { | |
326 | endVisit((Comment)node); | |
327 | } | |
328 | ||
329 | @Override | |
330 | public boolean visit(Javadoc node) { | |
331 | return visit((Comment)node); | |
332 | } | |
333 | ||
334 | @Override | |
335 | public void endVisit(Javadoc node) { | |
336 | endVisit((Comment)node); | |
337 | } | |
338 | ||
339 | @Override | |
340 | public boolean visit(LineComment node) { | |
341 | return visit((Comment)node); | |
342 | } | |
343 | ||
344 | @Override | |
345 | public void endVisit(LineComment node) { | |
346 | endVisit((Comment)node); | |
347 | } | |
348 | ||
349 | //---- End Comment Hierarchy ----------------------------- | |
350 | ||
351 | @Override | |
352 | public boolean visit(CompilationUnit node) { | |
353 | return visit((ASTNode)node); | |
354 | } | |
355 | ||
356 | @Override | |
357 | public void endVisit(CompilationUnit node) { | |
358 | endVisit((ASTNode)node); | |
359 | } | |
360 | ||
361 | //---- Begin Expression Hierarchy ---------------------------------- | |
362 | public boolean visit(Expression node) { | |
363 | return visit((ASTNode)node); | |
364 | } | |
365 | ||
366 | public void endVisit(Expression node) { | |
367 | endVisit((ASTNode)node); | |
368 | } | |
369 | ||
370 | //---- Begin Annotation Hierarchy ---------------------------------- | |
371 | public boolean visit(Annotation node) { | |
372 | return visit((Expression)node); | |
373 | } | |
374 | ||
375 | public void endVisit(Annotation node) { | |
376 | endVisit((Expression)node); | |
377 | } | |
378 | ||
379 | @Override | |
380 | public boolean visit(MarkerAnnotation node) { | |
381 | return visit((Annotation)node); | |
382 | } | |
383 | ||
384 | @Override | |
385 | public void endVisit(MarkerAnnotation node) { | |
386 | endVisit((Annotation)node); | |
387 | } | |
388 | ||
389 | @Override | |
390 | public boolean visit(NormalAnnotation node) { | |
391 | return visit((Annotation)node); | |
392 | } | |
393 | ||
394 | @Override | |
395 | public void endVisit(NormalAnnotation node) { | |
396 | endVisit((Annotation)node); | |
397 | } | |
398 | ||
399 | @Override | |
400 | public boolean visit(SingleMemberAnnotation node) { | |
401 | return visit((Annotation)node); | |
402 | } | |
403 | ||
404 | @Override | |
405 | public void endVisit(SingleMemberAnnotation node) { | |
406 | endVisit((Annotation)node); | |
407 | } | |
408 | ||
409 | //---- End Annotation Hierarchy ----------------------------- | |
410 | ||
411 | @Override | |
412 | public boolean visit(ArrayAccess node) { | |
413 | return visit((Expression)node); | |
414 | } | |
415 | ||
416 | @Override | |
417 | public void endVisit(ArrayAccess node) { | |
418 | endVisit((Expression)node); | |
419 | } | |
420 | ||
421 | @Override | |
422 | public boolean visit(ArrayCreation node) { | |
423 | return visit((Expression)node); | |
424 | } | |
425 | ||
426 | @Override | |
427 | public void endVisit(ArrayCreation node) { | |
428 | endVisit((Expression)node); | |
429 | } | |
430 | ||
431 | @Override | |
432 | public boolean visit(ArrayInitializer node) { | |
433 | return visit((Expression)node); | |
434 | } | |
435 | ||
436 | @Override | |
437 | public void endVisit(ArrayInitializer node) { | |
438 | endVisit((Expression)node); | |
439 | } | |
440 | ||
441 | @Override | |
442 | public boolean visit(Assignment node) { | |
443 | return visit((Expression)node); | |
444 | } | |
445 | ||
446 | @Override | |
447 | public void endVisit(Assignment node) { | |
448 | endVisit((Expression)node); | |
449 | } | |
450 | ||
451 | @Override | |
452 | public boolean visit(BooleanLiteral node) { | |
453 | return visit((Expression)node); | |
454 | } | |
455 | ||
456 | @Override | |
457 | public void endVisit(BooleanLiteral node) { | |
458 | endVisit((Expression)node); | |
459 | } | |
460 | ||
461 | @Override | |
462 | public boolean visit(CastExpression node) { | |
463 | return visit((Expression)node); | |
464 | } | |
465 | ||
466 | @Override | |
467 | public void endVisit(CastExpression node) { | |
468 | endVisit((Expression)node); | |
469 | } | |
470 | ||
471 | @Override | |
472 | public boolean visit(CharacterLiteral node) { | |
473 | return visit((Expression)node); | |
474 | } | |
475 | ||
476 | @Override | |
477 | public void endVisit(CharacterLiteral node) { | |
478 | endVisit((Expression)node); | |
479 | } | |
480 | ||
481 | @Override | |
482 | public boolean visit(ClassInstanceCreation node) { | |
483 | return visit((Expression)node); | |
484 | } | |
485 | ||
486 | @Override | |
487 | public void endVisit(ClassInstanceCreation node) { | |
488 | endVisit((Expression)node); | |
489 | } | |
490 | ||
491 | @Override | |
492 | public boolean visit(ConditionalExpression node) { | |
493 | return visit((Expression)node); | |
494 | } | |
495 | ||
496 | @Override | |
497 | public void endVisit(ConditionalExpression node) { | |
498 | endVisit((Expression)node); | |
499 | } | |
500 | ||
501 | @Override | |
502 | public boolean visit(FieldAccess node) { | |
503 | return visit((Expression)node); | |
504 | } | |
505 | ||
506 | @Override | |
507 | public void endVisit(FieldAccess node) { | |
508 | endVisit((Expression)node); | |
509 | } | |
510 | ||
511 | @Override | |
512 | public boolean visit(InfixExpression node) { | |
513 | return visit((Expression)node); | |
514 | } | |
515 | ||
516 | @Override | |
517 | public void endVisit(InfixExpression node) { | |
518 | endVisit((Expression)node); | |
519 | } | |
520 | ||
521 | @Override | |
522 | public boolean visit(InstanceofExpression node) { | |
523 | return visit((Expression)node); | |
524 | } | |
525 | ||
526 | @Override | |
527 | public void endVisit(InstanceofExpression node) { | |
528 | endVisit((Expression)node); | |
529 | } | |
530 | ||
531 | @Override | |
532 | public boolean visit(MethodInvocation node) { | |
533 | return visit((Expression)node); | |
534 | } | |
535 | ||
536 | @Override | |
537 | public void endVisit(MethodInvocation node) { | |
538 | endVisit((Expression)node); | |
539 | } | |
540 | ||
541 | //---- Begin Name Hierarchy ---------------------------------- | |
542 | public boolean visit(Name node) { | |
543 | return visit((Expression)node); | |
544 | } | |
545 | ||
546 | public void endVisit(Name node) { | |
547 | endVisit((Expression)node); | |
548 | } | |
549 | ||
550 | @Override | |
551 | public boolean visit(QualifiedName node) { | |
552 | return visit((Name)node); | |
553 | } | |
554 | ||
555 | @Override | |
556 | public void endVisit(QualifiedName node) { | |
557 | endVisit((Name)node); | |
558 | } | |
559 | ||
560 | @Override | |
561 | public boolean visit(SimpleName node) { | |
562 | return visit((Name)node); | |
563 | } | |
564 | ||
565 | @Override | |
566 | public void endVisit(SimpleName node) { | |
567 | endVisit((Name)node); | |
568 | } | |
569 | ||
570 | //---- End Name Hierarchy ------------------------------------ | |
571 | ||
572 | @Override | |
573 | public boolean visit(NullLiteral node) { | |
574 | return visit((Expression)node); | |
575 | } | |
576 | ||
577 | @Override | |
578 | public void endVisit(NullLiteral node) { | |
579 | endVisit((Expression)node); | |
580 | } | |
581 | ||
582 | @Override | |
583 | public boolean visit(NumberLiteral node) { | |
584 | return visit((Expression)node); | |
585 | } | |
586 | ||
587 | @Override | |
588 | public void endVisit(NumberLiteral node) { | |
589 | endVisit((Expression)node); | |
590 | } | |
591 | ||
592 | @Override | |
593 | public boolean visit(ParenthesizedExpression node) { | |
594 | return visit((Expression)node); | |
595 | } | |
596 | ||
597 | @Override | |
598 | public void endVisit(ParenthesizedExpression node) { | |
599 | endVisit((Expression)node); | |
600 | } | |
601 | ||
602 | @Override | |
603 | public boolean visit(PostfixExpression node) { | |
604 | return visit((Expression)node); | |
605 | } | |
606 | ||
607 | @Override | |
608 | public void endVisit(PostfixExpression node) { | |
609 | endVisit((Expression)node); | |
610 | } | |
611 | ||
612 | @Override | |
613 | public boolean visit(PrefixExpression node) { | |
614 | return visit((Expression)node); | |
615 | } | |
616 | ||
617 | @Override | |
618 | public void endVisit(PrefixExpression node) { | |
619 | endVisit((Expression)node); | |
620 | } | |
621 | ||
622 | @Override | |
623 | public boolean visit(StringLiteral node) { | |
624 | return visit((Expression)node); | |
625 | } | |
626 | ||
627 | @Override | |
628 | public void endVisit(StringLiteral node) { | |
629 | endVisit((Expression)node); | |
630 | } | |
631 | ||
632 | @Override | |
633 | public boolean visit(SuperFieldAccess node) { | |
634 | return visit((Expression)node); | |
635 | } | |
636 | ||
637 | @Override | |
638 | public void endVisit(SuperFieldAccess node) { | |
639 | endVisit((Expression)node); | |
640 | } | |
641 | ||
642 | @Override | |
643 | public boolean visit(SuperMethodInvocation node) { | |
644 | return visit((Expression)node); | |
645 | } | |
646 | ||
647 | @Override | |
648 | public void endVisit(SuperMethodInvocation node) { | |
649 | endVisit((Expression)node); | |
650 | } | |
651 | ||
652 | @Override | |
653 | public boolean visit(ThisExpression node) { | |
654 | return visit((Expression)node); | |
655 | } | |
656 | ||
657 | @Override | |
658 | public void endVisit(ThisExpression node) { | |
659 | endVisit((Expression)node); | |
660 | } | |
661 | ||
662 | @Override | |
663 | public boolean visit(TypeLiteral node) { | |
664 | return visit((Expression)node); | |
665 | } | |
666 | ||
667 | @Override | |
668 | public void endVisit(TypeLiteral node) { | |
669 | endVisit((Expression)node); | |
670 | } | |
671 | ||
672 | @Override | |
673 | public boolean visit(VariableDeclarationExpression node) { | |
674 | return visit((Expression)node); | |
675 | } | |
676 | ||
677 | @Override | |
678 | public void endVisit(VariableDeclarationExpression node) { | |
679 | endVisit((Expression)node); | |
680 | } | |
681 | ||
682 | //---- End Expression Hierarchy ---------------------------------- | |
683 | ||
684 | @Override | |
685 | public boolean visit(ImportDeclaration node) { | |
686 | return visit((ASTNode)node); | |
687 | } | |
688 | ||
689 | @Override | |
690 | public void endVisit(ImportDeclaration node) { | |
691 | endVisit((ASTNode)node); | |
692 | } | |
693 | ||
694 | @Override | |
695 | public boolean visit(MemberRef node) { | |
696 | return visit((ASTNode)node); | |
697 | } | |
698 | ||
699 | @Override | |
700 | public void endVisit(MemberRef node) { | |
701 | endVisit((ASTNode)node); | |
702 | } | |
703 | ||
704 | @Override | |
705 | public boolean visit(MemberValuePair node) { | |
706 | return visit((ASTNode)node); | |
707 | } | |
708 | ||
709 | @Override | |
710 | public void endVisit(MemberValuePair node) { | |
711 | endVisit((ASTNode)node); | |
712 | } | |
713 | ||
714 | @Override | |
715 | public boolean visit(MethodRef node) { | |
716 | return visit((ASTNode)node); | |
717 | } | |
718 | ||
719 | @Override | |
720 | public void endVisit(MethodRef node) { | |
721 | endVisit((ASTNode)node); | |
722 | } | |
723 | ||
724 | @Override | |
725 | public boolean visit(MethodRefParameter node) { | |
726 | return visit((ASTNode)node); | |
727 | } | |
728 | ||
729 | @Override | |
730 | public void endVisit(MethodRefParameter node) { | |
731 | endVisit((ASTNode)node); | |
732 | } | |
733 | ||
734 | @Override | |
735 | public boolean visit(Modifier node) { | |
736 | return visit((ASTNode)node); | |
737 | } | |
738 | ||
739 | @Override | |
740 | public void endVisit(Modifier node) { | |
741 | endVisit((ASTNode)node); | |
742 | } | |
743 | ||
744 | @Override | |
745 | public boolean visit(PackageDeclaration node) { | |
746 | return visit((ASTNode)node); | |
747 | } | |
748 | ||
749 | @Override | |
750 | public void endVisit(PackageDeclaration node) { | |
751 | endVisit((ASTNode)node); | |
752 | } | |
753 | ||
754 | //---- Begin Statement Hierarchy --------------------------------- | |
755 | public boolean visit(Statement node) { | |
756 | return visit((ASTNode)node); | |
757 | } | |
758 | ||
759 | public void endVisit(Statement node) { | |
760 | endVisit((ASTNode)node); | |
761 | } | |
762 | ||
763 | ||
764 | @Override | |
765 | public boolean visit(AssertStatement node) { | |
766 | return visit((Statement)node); | |
767 | } | |
768 | ||
769 | @Override | |
770 | public void endVisit(AssertStatement node) { | |
771 | endVisit((Statement)node); | |
772 | } | |
773 | ||
774 | @Override | |
775 | public boolean visit(Block node) { | |
776 | return visit((Statement)node); | |
777 | } | |
778 | ||
779 | @Override | |
780 | public void endVisit(Block node) { | |
781 | endVisit((Statement)node); | |
782 | } | |
783 | ||
784 | @Override | |
785 | public boolean visit(BreakStatement node) { | |
786 | return visit((Statement)node); | |
787 | } | |
788 | ||
789 | @Override | |
790 | public void endVisit(BreakStatement node) { | |
791 | endVisit((Statement)node); | |
792 | } | |
793 | ||
794 | @Override | |
795 | public boolean visit(ConstructorInvocation node) { | |
796 | return visit((Statement)node); | |
797 | } | |
798 | ||
799 | @Override | |
800 | public void endVisit(ConstructorInvocation node) { | |
801 | endVisit((Statement)node); | |
802 | } | |
803 | ||
804 | @Override | |
805 | public boolean visit(ContinueStatement node) { | |
806 | return visit((Statement)node); | |
807 | } | |
808 | ||
809 | @Override | |
810 | public void endVisit(ContinueStatement node) { | |
811 | endVisit((Statement)node); | |
812 | } | |
813 | ||
814 | @Override | |
815 | public boolean visit(DoStatement node) { | |
816 | return visit((Statement)node); | |
817 | } | |
818 | ||
819 | @Override | |
820 | public void endVisit(DoStatement node) { | |
821 | endVisit((Statement)node); | |
822 | } | |
823 | ||
824 | @Override | |
825 | public boolean visit(EmptyStatement node) { | |
826 | return visit((Statement)node); | |
827 | } | |
828 | ||
829 | @Override | |
830 | public void endVisit(EmptyStatement node) { | |
831 | endVisit((Statement)node); | |
832 | } | |
833 | ||
834 | @Override | |
835 | public boolean visit(EnhancedForStatement node) { | |
836 | return visit((Statement)node); | |
837 | } | |
838 | ||
839 | @Override | |
840 | public void endVisit(EnhancedForStatement node) { | |
841 | endVisit((Statement)node); | |
842 | } | |
843 | ||
844 | @Override | |
845 | public boolean visit(ExpressionStatement node) { | |
846 | return visit((Statement)node); | |
847 | } | |
848 | ||
849 | @Override | |
850 | public void endVisit(ExpressionStatement node) { | |
851 | endVisit((Statement)node); | |
852 | } | |
853 | ||
854 | @Override | |
855 | public boolean visit(ForStatement node) { | |
856 | return visit((Statement)node); | |
857 | } | |
858 | ||
859 | @Override | |
860 | public void endVisit(ForStatement node) { | |
861 | endVisit((Statement)node); | |
862 | } | |
863 | ||
864 | @Override | |
865 | public boolean visit(IfStatement node) { | |
866 | return visit((Statement)node); | |
867 | } | |
868 | ||
869 | @Override | |
870 | public void endVisit(IfStatement node) { | |
871 | endVisit((Statement)node); | |
872 | } | |
873 | ||
874 | @Override | |
875 | public boolean visit(LabeledStatement node) { | |
876 | return visit((Statement)node); | |
877 | } | |
878 | ||
879 | @Override | |
880 | public void endVisit(LabeledStatement node) { | |
881 | endVisit((Statement)node); | |
882 | } | |
883 | ||
884 | @Override | |
885 | public boolean visit(ReturnStatement node) { | |
886 | return visit((Statement)node); | |
887 | } | |
888 | ||
889 | @Override | |
890 | public void endVisit(ReturnStatement node) { | |
891 | endVisit((Statement)node); | |
892 | } | |
893 | ||
894 | @Override | |
895 | public boolean visit(SuperConstructorInvocation node) { | |
896 | return visit((Statement)node); | |
897 | } | |
898 | ||
899 | @Override | |
900 | public void endVisit(SuperConstructorInvocation node) { | |
901 | endVisit((Statement)node); | |
902 | } | |
903 | ||
904 | @Override | |
905 | public boolean visit(SwitchCase node) { | |
906 | return visit((Statement)node); | |
907 | } | |
908 | ||
909 | @Override | |
910 | public void endVisit(SwitchCase node) { | |
911 | endVisit((Statement)node); | |
912 | } | |
913 | ||
914 | @Override | |
915 | public boolean visit(SwitchStatement node) { | |
916 | return visit((Statement)node); | |
917 | } | |
918 | ||
919 | @Override | |
920 | public void endVisit(SwitchStatement node) { | |
921 | endVisit((Statement)node); | |
922 | } | |
923 | ||
924 | @Override | |
925 | public boolean visit(SynchronizedStatement node) { | |
926 | return visit((Statement)node); | |
927 | } | |
928 | ||
929 | @Override | |
930 | public void endVisit(SynchronizedStatement node) { | |
931 | endVisit((Statement)node); | |
932 | } | |
933 | ||
934 | @Override | |
935 | public boolean visit(ThrowStatement node) { | |
936 | return visit((Statement)node); | |
937 | } | |
938 | ||
939 | @Override | |
940 | public void endVisit(ThrowStatement node) { | |
941 | endVisit((Statement)node); | |
942 | } | |
943 | ||
944 | @Override | |
945 | public boolean visit(TryStatement node) { | |
946 | return visit((Statement)node); | |
947 | } | |
948 | ||
949 | @Override | |
950 | public void endVisit(TryStatement node) { | |
951 | endVisit((Statement)node); | |
952 | } | |
953 | ||
954 | @Override | |
955 | public boolean visit(TypeDeclarationStatement node) { | |
956 | return visit((Statement)node); | |
957 | } | |
958 | ||
959 | @Override | |
960 | public void endVisit(TypeDeclarationStatement node) { | |
961 | endVisit((Statement)node); | |
962 | } | |
963 | ||
964 | @Override | |
965 | public boolean visit(VariableDeclarationStatement node) { | |
966 | return visit((Statement)node); | |
967 | } | |
968 | ||
969 | @Override | |
970 | public void endVisit(VariableDeclarationStatement node) { | |
971 | endVisit((Statement)node); | |
972 | } | |
973 | ||
974 | @Override | |
975 | public boolean visit(WhileStatement node) { | |
976 | return visit((Statement)node); | |
977 | } | |
978 | ||
979 | @Override | |
980 | public void endVisit(WhileStatement node) { | |
981 | endVisit((Statement)node); | |
982 | } | |
983 | ||
984 | //---- End Statement Hierarchy ---------------------------------- | |
985 | ||
986 | @Override | |
987 | public boolean visit(TagElement node) { | |
988 | return visit((ASTNode)node); | |
989 | } | |
990 | ||
991 | @Override | |
992 | public void endVisit(TagElement node) { | |
993 | endVisit((ASTNode)node); | |
994 | } | |
995 | ||
996 | @Override | |
997 | public boolean visit(TextElement node) { | |
998 | return visit((ASTNode)node); | |
999 | } | |
1000 | ||
1001 | @Override | |
1002 | public void endVisit(TextElement node) { | |
1003 | endVisit((ASTNode)node); | |
1004 | } | |
1005 | ||
1006 | ||
1007 | //---- Begin Type Hierarchy -------------------------------------- | |
1008 | public boolean visit(Type node) { | |
1009 | return visit((ASTNode)node); | |
1010 | } | |
1011 | ||
1012 | public void endVisit(Type node) { | |
1013 | endVisit((ASTNode)node); | |
1014 | } | |
1015 | ||
1016 | @Override | |
1017 | public boolean visit(ArrayType node) { | |
1018 | return visit((Type)node); | |
1019 | } | |
1020 | ||
1021 | @Override | |
1022 | public void endVisit(ArrayType node) { | |
1023 | endVisit((Type)node); | |
1024 | } | |
1025 | ||
1026 | @Override | |
1027 | public boolean visit(ParameterizedType node) { | |
1028 | return visit((Type)node); | |
1029 | } | |
1030 | ||
1031 | @Override | |
1032 | public void endVisit(ParameterizedType node) { | |
1033 | endVisit((Type)node); | |
1034 | } | |
1035 | ||
1036 | @Override | |
1037 | public boolean visit(PrimitiveType node) { | |
1038 | return visit((Type)node); | |
1039 | } | |
1040 | ||
1041 | @Override | |
1042 | public void endVisit(PrimitiveType node) { | |
1043 | endVisit((Type)node); | |
1044 | } | |
1045 | ||
1046 | @Override | |
1047 | public boolean visit(QualifiedType node) { | |
1048 | return visit((Type)node); | |
1049 | } | |
1050 | ||
1051 | @Override | |
1052 | public void endVisit(QualifiedType node) { | |
1053 | endVisit((Type)node); | |
1054 | } | |
1055 | ||
1056 | @Override | |
1057 | public boolean visit(SimpleType node) { | |
1058 | return visit((Type)node); | |
1059 | } | |
1060 | ||
1061 | @Override | |
1062 | public void endVisit(SimpleType node) { | |
1063 | endVisit((Type)node); | |
1064 | } | |
1065 | ||
1066 | @Override | |
1067 | public boolean visit(WildcardType node) { | |
1068 | return visit((Type)node); | |
1069 | } | |
1070 | ||
1071 | @Override | |
1072 | public void endVisit(WildcardType node) { | |
1073 | endVisit((Type)node); | |
1074 | } | |
1075 | ||
1076 | @Override | |
1077 | public boolean visit(UnionType node) { | |
1078 | return visit((Type)node); | |
1079 | } | |
1080 | ||
1081 | @Override | |
1082 | public void endVisit(UnionType node) { | |
1083 | endVisit((Type)node); | |
1084 | } | |
1085 | ||
1086 | //---- End Type Hierarchy ---------------------------------------- | |
1087 | ||
1088 | @Override | |
1089 | public boolean visit(TypeParameter node) { | |
1090 | return visit((ASTNode)node); | |
1091 | } | |
1092 | ||
1093 | @Override | |
1094 | public void endVisit(TypeParameter node) { | |
1095 | endVisit((ASTNode)node); | |
1096 | } | |
1097 | ||
1098 | ||
1099 | //---- Begin VariableDeclaration Hierarchy --------------------------- | |
1100 | public boolean visit(VariableDeclaration node) { | |
1101 | return visit((ASTNode)node); | |
1102 | } | |
1103 | ||
1104 | public void endVisit(VariableDeclaration node) { | |
1105 | endVisit((ASTNode)node); | |
1106 | } | |
1107 | ||
1108 | @Override | |
1109 | public boolean visit(SingleVariableDeclaration node) { | |
1110 | return visit((VariableDeclaration)node); | |
1111 | } | |
1112 | ||
1113 | @Override | |
1114 | public void endVisit(SingleVariableDeclaration node) { | |
1115 | endVisit((VariableDeclaration)node); | |
1116 | } | |
1117 | ||
1118 | @Override | |
1119 | public boolean visit(VariableDeclarationFragment node) { | |
1120 | return visit((VariableDeclaration)node); | |
1121 | } | |
1122 | ||
1123 | @Override | |
1124 | public void endVisit(VariableDeclarationFragment node) { | |
1125 | endVisit((VariableDeclaration)node); | |
1126 | } | |
1127 | ||
1128 | //---- End VariableDeclaration Hierarchy ----------------------------- | |
1129 | //---- End ASTNode Hierarchy ----------------------------------------- | |
1130 | } |