Attachment #63764 for bug #181393

View | Details | Raw Unified | Return to bug 181393
Collapse All | Expand All




		super(visitDocTags);
	}
	
	public void endVisit(AnnotationTypeDeclaration node) {
		endVisitNode(node);
	}
	
	public void endVisit(AnnotationTypeMemberDeclaration node) {
		endVisitNode(node);
	}

	public boolean visit(AnonymousClassDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(ArrayAccess node) {
		return visitNode(node);
	}
	public boolean visit(ArrayCreation node) {
		return visitNode(node);
	}
	public boolean visit(ArrayInitializer node) {
		return visitNode(node);
	}
	public boolean visit(ArrayType node) {
		visitNode(node);
		return false;
	}
	public boolean visit(AssertStatement node) {
		return visitNode(node);
	}
	public boolean visit(Assignment node) {
		return visitNode(node);
	}
	public boolean visit(Block node) {
		return visitNode(node);
	}
	public boolean visit(BooleanLiteral node) {
		return visitNode(node);
	}
	public boolean visit(BreakStatement node) {
		return visitNode(node);
	}
	public boolean visit(CastExpression node) {
		return visitNode(node);
	}
	public boolean visit(CatchClause node) {
		return visitNode(node);
	}
	public boolean visit(CharacterLiteral node) {
		return visitNode(node);
	}
	public boolean visit(ClassInstanceCreation node) {
		return visitNode(node);
	}
	public boolean visit(CompilationUnit node) {
		return visitNode(node);
	}
	public boolean visit(ConditionalExpression node) {
		return visitNode(node);
	}
	public boolean visit(ConstructorInvocation node) {
		return visitNode(node);
	}
	public boolean visit(ContinueStatement node) {
		return visitNode(node);
	}
	public boolean visit(DoStatement node) {
		return visitNode(node);
	}
	public boolean visit(EmptyStatement node) {
		return visitNode(node);
	}
	public boolean visit(EnumConstantDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(EnumDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(ExpressionStatement node) {
		return visitNode(node);
	}
	public boolean visit(FieldAccess node) {
		return visitNode(node);
	}
	public boolean visit(FieldDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(ForStatement node) {
		return visitNode(node);
	}
	public boolean visit(IfStatement node) {
		return visitNode(node);
	}
	public boolean visit(ImportDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(InfixExpression node) {
		return visitNode(node);
	}
	public boolean visit(InstanceofExpression node) {
		return visitNode(node);
	}
	public boolean visit(Initializer node) {
		return visitNode(node);
	}
	public boolean visit(Javadoc node) {
		//	do not visit Javadoc tags by default. Use constructor with boolean to enable.
		if (super.visit(node)) { 
			return visitNode(node);
		}
		return false;
	}
	public boolean visit(LabeledStatement node) {
		return visitNode(node);
	}
	public boolean visit(MethodDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(MethodInvocation node) {
		return visitNode(node);
	}
	public boolean visit(NullLiteral node) {
		return visitNode(node);
	}
	public boolean visit(NumberLiteral node) {
		return visitNode(node);
	}
	public boolean visit(PackageDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(ParenthesizedExpression node) {
		return visitNode(node);
	}
	public boolean visit(PostfixExpression node) {
		return visitNode(node);
	}
	public boolean visit(PrefixExpression node) {
		return visitNode(node);
	}
	public boolean visit(PrimitiveType node) {
		return visitNode(node);
	}
	public boolean visit(QualifiedName node) {
		return visitNode(node);
	}
	public boolean visit(ReturnStatement node) {
		return visitNode(node);
	}
	public boolean visit(SimpleName node) {
		return visitNode(node);
	}
	public boolean visit(SimpleType node) {
		return visitNode(node);
	}
	public boolean visit(StringLiteral node) {
		return visitNode(node);
	}
	public boolean visit(SuperConstructorInvocation node) {
		return visitNode(node);
	}
	public boolean visit(SuperFieldAccess node) {
		return visitNode(node);
	}
	public boolean visit(SuperMethodInvocation node) {
		return visitNode(node);
	}
	public boolean visit(SwitchCase node) {
		return visitNode(node);
	}
	public boolean visit(SwitchStatement node) {
		return visitNode(node);
	}
	public boolean visit(SynchronizedStatement node) {
		return visitNode(node);
	}
	public boolean visit(ThisExpression node) {
		return visitNode(node);
	}
	public boolean visit(ThrowStatement node) {
		return visitNode(node);
	}
	public boolean visit(TryStatement node) {
		return visitNode(node);
	}
	public boolean visit(TypeDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(TypeDeclarationStatement node) {
		return visitNode(node);
	}
	public boolean visit(TypeLiteral node) {
		return visitNode(node);
	}
	public boolean visit(SingleVariableDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(VariableDeclarationExpression node) {
		return visitNode(node);
	}
	public boolean visit(VariableDeclarationStatement node) {
		return visitNode(node);
	}
	public boolean visit(VariableDeclarationFragment node) {
		return visitNode(node);
	}
	public boolean visit(WhileStatement node) {
		return visitNode(node);
	}

	/* since 3.0 */
	public boolean visit(BlockComment node) {
		return visitNode(node);
	}
	public boolean visit(LineComment node) {
		return visitNode(node);
	}
	public boolean visit(MarkerAnnotation node) {
		return visitNode(node);
	}
	public boolean visit(MemberRef node) {
		return visitNode(node);
	}
	public boolean visit(MethodRef node) {
		return visitNode(node);
	}
	public boolean visit(MethodRefParameter node) {
		return visitNode(node);
	}
	public boolean visit(TagElement node) {
		return visitNode(node);
	}
	public boolean visit(TextElement node) {
		return visitNode(node);
	}

	public void endVisit(AnonymousClassDeclaration node) {

	public void endVisit(Block node) {
		endVisitNode(node);
	}
	/* since 3.0 */
	public void endVisit(BlockComment node) {
		endVisitNode(node);
	}
	public void endVisit(BooleanLiteral node) {
		endVisitNode(node);
	}

	public void endVisit(EmptyStatement node) {
		endVisitNode(node);
	}
	public void endVisit(EnhancedForStatement node) {
		endVisitNode(node);
	}
	public void endVisit(EnumConstantDeclaration node) {
		endVisitNode(node);
	}

	public void endVisit(InfixExpression node) {
		endVisitNode(node);
	}
	public void endVisit(Initializer node) {
		endVisitNode(node);
	}
	public void endVisit(InstanceofExpression node) {
		endVisitNode(node);
	}
	public void endVisit(Javadoc node) {

	public void endVisit(LabeledStatement node) {
		endVisitNode(node);
	}
	public void endVisit(LineComment node) {
		endVisitNode(node);
	}
	public void endVisit(MarkerAnnotation node) {
		endVisitNode(node);
	}
	public void endVisit(MemberRef node) {
		endVisitNode(node);
	}
	public void endVisit(MemberValuePair node) {
		endVisitNode(node);
	}
	public void endVisit(MethodDeclaration node) {
		endVisitNode(node);
	}
	public void endVisit(MethodInvocation node) {
		endVisitNode(node);
	}
	public void endVisit(MethodRef node) {
		endVisitNode(node);
	}
	public void endVisit(MethodRefParameter node) {
		endVisitNode(node);
	}
	public void endVisit(NormalAnnotation node) {
		endVisitNode(node);
	}
	public void endVisit(NullLiteral node) {
		endVisitNode(node);
	}
	public void endVisit(NumberLiteral node) {
		endVisitNode(node);
	}
	public void endVisit(PackageDeclaration node) {
		endVisitNode(node);
	}
	public void endVisit(ParameterizedType node) {
		endVisitNode(node);
	}
	public void endVisit(ParenthesizedExpression node) {
		endVisitNode(node);
	}
	public void endVisit(PostfixExpression node) {
		endVisitNode(node);
	}
	public void endVisit(PrefixExpression node) {
		endVisitNode(node);
	}
	public void endVisit(PrimitiveType node) {
		endVisitNode(node);
	}
	public void endVisit(QualifiedName node) {
		endVisitNode(node);
	}
	public void endVisit(QualifiedType node) {
		endVisitNode(node);
	}
	public void endVisit(ReturnStatement node) {
		endVisitNode(node);
	}

	public void endVisit(SimpleType node) {
		endVisitNode(node);
	}
	public void endVisit(SingleMemberAnnotation node) {
		endVisitNode(node);
	}
	public void endVisit(SingleVariableDeclaration node) {
		endVisitNode(node);
	}
	public void endVisit(StringLiteral node) {
		endVisitNode(node);
	}

	public void endVisit(SuperMethodInvocation node) {
		endVisitNode(node);
	}

	public void endVisit(SwitchCase node) {
		endVisitNode(node);
	}

	public void endVisit(SynchronizedStatement node) {
		endVisitNode(node);
	}
	public void endVisit(TagElement node) {
		endVisitNode(node);
	}
	public void endVisit(TextElement node) {
		endVisitNode(node);
	}
	public void endVisit(ThisExpression node) {
		endVisitNode(node);
	}

	public void endVisit(TryStatement node) {
		endVisitNode(node);
	}

	public void endVisit(TypeDeclaration node) {
		endVisitNode(node);
	}

	public void endVisit(TypeLiteral node) {
		endVisitNode(node);
	}
	public void endVisit(TypeParameter node) {
		endVisitNode(node);
	}
	public void endVisit(VariableDeclarationExpression node) {
		endVisitNode(node);
	}
	public void endVisit(VariableDeclarationFragment node) {
		endVisitNode(node);
	}
	public void endVisit(VariableDeclarationStatement node) {
		endVisitNode(node);
	}
	public void endVisit(WhileStatement node) {
		endVisitNode(node);
	}
	public void endVisit(WildcardType node) {
	/* since 3.0 */
	public void endVisit(BlockComment node) {
		endVisitNode(node);
	}
	protected void endVisitNode(ASTNode node) {
		// do nothing
	}
	public boolean visit(AnnotationTypeDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(AnnotationTypeMemberDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(AnonymousClassDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(ArrayAccess node) {
		return visitNode(node);
	}
	public boolean visit(ArrayCreation node) {
		return visitNode(node);
	}
	public boolean visit(ArrayInitializer node) {
		return visitNode(node);
	}
	public boolean visit(ArrayType node) {
		visitNode(node);
		return false;
	}
	public boolean visit(AssertStatement node) {
		return visitNode(node);
	}
	public boolean visit(Assignment node) {
		return visitNode(node);
	}
	public boolean visit(Block node) {
		return visitNode(node);
	}
	/* since 3.0 */
	public boolean visit(BlockComment node) {
		return visitNode(node);
	}
	public boolean visit(BooleanLiteral node) {
		return visitNode(node);
	}
	public boolean visit(BreakStatement node) {
		return visitNode(node);
	}
	public boolean visit(CastExpression node) {
		return visitNode(node);
	}
	public boolean visit(CatchClause node) {
		return visitNode(node);
	}
	public boolean visit(CharacterLiteral node) {
		return visitNode(node);
	}
	public boolean visit(ClassInstanceCreation node) {
		return visitNode(node);
	}
	public boolean visit(CompilationUnit node) {
		return visitNode(node);
	}
	public boolean visit(ConditionalExpression node) {
		return visitNode(node);
	}
	public boolean visit(ConstructorInvocation node) {
		return visitNode(node);
	}
	public boolean visit(ContinueStatement node) {
		return visitNode(node);
	}
	public boolean visit(DoStatement node) {
		return visitNode(node);
	}
	public boolean visit(EmptyStatement node) {
		return visitNode(node);
	}
	public boolean visit(EnhancedForStatement node) {
		return visitNode(node);
	}
	public boolean visit(EnumConstantDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(EnumDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(ExpressionStatement node) {
		return visitNode(node);
	}
	public boolean visit(FieldAccess node) {
		return visitNode(node);
	}
	public boolean visit(FieldDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(ForStatement node) {
		return visitNode(node);
	}
	public boolean visit(IfStatement node) {
		return visitNode(node);
	}
	public boolean visit(ImportDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(InfixExpression node) {
		return visitNode(node);
	}
	public boolean visit(Initializer node) {
		return visitNode(node);
	}
	public boolean visit(InstanceofExpression node) {
		return visitNode(node);
	}
	public boolean visit(Javadoc node) {
		//	do not visit Javadoc tags by default. Use constructor with boolean to enable.
		if (super.visit(node)) { 
			return visitNode(node);
		}
		return false;
	}
	public boolean visit(LabeledStatement node) {
		return visitNode(node);
	}
	public boolean visit(LineComment node) {
		return visitNode(node);
	}
	public boolean visit(MarkerAnnotation node) {
		return visitNode(node);
	}
	public boolean visit(MemberRef node) {
		return visitNode(node);
	}
	public boolean visit(MemberValuePair node) {
		return visitNode(node);
	}
	public boolean visit(MethodDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(MethodInvocation node) {
		return visitNode(node);
	}
	public boolean visit(MethodRef node) {
		return visitNode(node);
	}
	public boolean visit(MethodRefParameter node) {
		return visitNode(node);
	}
	public boolean visit(NormalAnnotation node) {
		return visitNode(node);
	}
	public boolean visit(NullLiteral node) {
		return visitNode(node);
	}
	public boolean visit(NumberLiteral node) {
		return visitNode(node);
	}
	public boolean visit(PackageDeclaration node) {
		return visitNode(node);
	}
	public boolean visit(ParameterizedType node) {
		return visitNode(node);
	}
	public boolean visit(ParenthesizedExpression node) {
		return visitNode(node);
	}
	public boolean visit(PostfixExpression node) {
		return visitNode(node);
	}
	public boolean visit(PrefixExpression node) {
		return visitNode(node);
	}
	
	public boolean visit(PrimitiveType node) {
		return visitNode(node);
	}
	public boolean visit(QualifiedName node) {
		return visitNode(node);
	}
	public boolean visit(QualifiedType node) {
		return visitNode(node);
	}
	public boolean visit(ReturnStatement node) {
		return visitNode(node);
	}
	public boolean visit(SimpleName node) {
		return visitNode(node);
	}
	public boolean visit(SimpleType node) {
		return visitNode(node);
	}
	public boolean visit(SingleMemberAnnotation node) {
		return visitNode(node);
	}
	public boolean visit(SingleVariableDeclaration node) {
		return visitNode(node);
	}

	public boolean visit(StringLiteral node) {
		return visitNode(node);
	}

	public boolean visit(SuperConstructorInvocation node) {
		return visitNode(node);
	}

	public boolean visit(SuperFieldAccess node) {
		return visitNode(node);
	}

	public boolean visit(SuperMethodInvocation node) {
		return visitNode(node);
	}

	public boolean visit(SwitchCase node) {
		return visitNode(node);
	}

	public boolean visit(SwitchStatement node) {
		return visitNode(node);
	}

	public boolean visit(SynchronizedStatement node) {
		return visitNode(node);
	}

	public boolean visit(TagElement node) {
		return visitNode(node);
	}

	public boolean visit(TextElement node) {
		return visitNode(node);
	}

	public boolean visit(ThisExpression node) {
		return visitNode(node);
	}

	public boolean visit(ThrowStatement node) {
		return visitNode(node);
	}

	public boolean visit(TryStatement node) {
		return visitNode(node);
	}

	public boolean visit(TypeDeclaration node) {
		return visitNode(node);
	}

	public boolean visit(TypeDeclarationStatement node) {
		return visitNode(node);
	}

	public boolean visit(TypeLiteral node) {
		return visitNode(node);
	}

	public boolean visit(TypeParameter node) {
		return visitNode(node);
	}

	public boolean visit(VariableDeclarationExpression node) {
		return visitNode(node);
	}

	public boolean visit(VariableDeclarationFragment node) {
		return visitNode(node);
	}

	public boolean visit(VariableDeclarationStatement node) {
		return visitNode(node);
	}

	public boolean visit(WhileStatement node) {
		return visitNode(node);
	}

	public boolean visit(WildcardType node) {
		return visitNode(node);
	}

	protected boolean visitNode(ASTNode node) {
		return true;
	}

}

Return to bug 181393

Lines 26-261 Link Here

(-)dom/org/eclipse/jdt/core/dom/DefaultASTVisitor.java (-259 / +341 lines)
26	super(visitDocTags);	26	super(visitDocTags);
27	}	27	}
28		28
29	protected boolean visitNode(ASTNode node) {	29	public void endVisit(AnnotationTypeDeclaration node) {
30	return true;	30	endVisitNode(node);
31	}	31	}
32		32
33	protected void endVisitNode(ASTNode node) {	33	public void endVisit(AnnotationTypeMemberDeclaration node) {
34	// do nothing	34	endVisitNode(node);
35	}
36
37	public boolean visit(AnonymousClassDeclaration node) {
38	return visitNode(node);
39	}
40	public boolean visit(ArrayAccess node) {
41	return visitNode(node);
42	}
43	public boolean visit(ArrayCreation node) {
44	return visitNode(node);
45	}
46	public boolean visit(ArrayInitializer node) {
47	return visitNode(node);
48	}
49	public boolean visit(ArrayType node) {
50	visitNode(node);
51	return false;
52	}
53	public boolean visit(AssertStatement node) {
54	return visitNode(node);
55	}
56	public boolean visit(Assignment node) {
57	return visitNode(node);
58	}
59	public boolean visit(Block node) {
60	return visitNode(node);
61	}
62	public boolean visit(BooleanLiteral node) {
63	return visitNode(node);
64	}
65	public boolean visit(BreakStatement node) {
66	return visitNode(node);
67	}
68	public boolean visit(CastExpression node) {
69	return visitNode(node);
70	}
71	public boolean visit(CatchClause node) {
72	return visitNode(node);
73	}
74	public boolean visit(CharacterLiteral node) {
75	return visitNode(node);
76	}
77	public boolean visit(ClassInstanceCreation node) {
78	return visitNode(node);
79	}
80	public boolean visit(CompilationUnit node) {
81	return visitNode(node);
82	}
83	public boolean visit(ConditionalExpression node) {
84	return visitNode(node);
85	}
86	public boolean visit(ConstructorInvocation node) {
87	return visitNode(node);
88	}
89	public boolean visit(ContinueStatement node) {
90	return visitNode(node);
91	}
92	public boolean visit(DoStatement node) {
93	return visitNode(node);
94	}
95	public boolean visit(EmptyStatement node) {
96	return visitNode(node);
97	}
98	public boolean visit(EnumConstantDeclaration node) {
99	return visitNode(node);
100	}
101	public boolean visit(EnumDeclaration node) {
102	return visitNode(node);
103	}
104	public boolean visit(ExpressionStatement node) {
105	return visitNode(node);
106	}
107	public boolean visit(FieldAccess node) {
108	return visitNode(node);
109	}
110	public boolean visit(FieldDeclaration node) {
111	return visitNode(node);
112	}
113	public boolean visit(ForStatement node) {
114	return visitNode(node);
115	}
116	public boolean visit(IfStatement node) {
117	return visitNode(node);
118	}
119	public boolean visit(ImportDeclaration node) {
120	return visitNode(node);
121	}
122	public boolean visit(InfixExpression node) {
123	return visitNode(node);
124	}
125	public boolean visit(InstanceofExpression node) {
126	return visitNode(node);
127	}
128	public boolean visit(Initializer node) {
129	return visitNode(node);
130	}
131	public boolean visit(Javadoc node) {
132	// do not visit Javadoc tags by default. Use constructor with boolean to enable.
133	if (super.visit(node)) {
134	return visitNode(node);
135	}
136	return false;
137	}
138	public boolean visit(LabeledStatement node) {
139	return visitNode(node);
140	}
141	public boolean visit(MethodDeclaration node) {
142	return visitNode(node);
143	}
144	public boolean visit(MethodInvocation node) {
145	return visitNode(node);
146	}
147	public boolean visit(NullLiteral node) {
148	return visitNode(node);
149	}
150	public boolean visit(NumberLiteral node) {
151	return visitNode(node);
152	}
153	public boolean visit(PackageDeclaration node) {
154	return visitNode(node);
155	}
156	public boolean visit(ParenthesizedExpression node) {
157	return visitNode(node);
158	}
159	public boolean visit(PostfixExpression node) {
160	return visitNode(node);
161	}
162	public boolean visit(PrefixExpression node) {
163	return visitNode(node);
164	}
165	public boolean visit(PrimitiveType node) {
166	return visitNode(node);
167	}
168	public boolean visit(QualifiedName node) {
169	return visitNode(node);
170	}
171	public boolean visit(ReturnStatement node) {
172	return visitNode(node);
173	}
174	public boolean visit(SimpleName node) {
175	return visitNode(node);
176	}
177	public boolean visit(SimpleType node) {
178	return visitNode(node);
179	}
180	public boolean visit(StringLiteral node) {
181	return visitNode(node);
182	}
183	public boolean visit(SuperConstructorInvocation node) {
184	return visitNode(node);
185	}
186	public boolean visit(SuperFieldAccess node) {
187	return visitNode(node);
188	}
189	public boolean visit(SuperMethodInvocation node) {
190	return visitNode(node);
191	}
192	public boolean visit(SwitchCase node) {
193	return visitNode(node);
194	}
195	public boolean visit(SwitchStatement node) {
196	return visitNode(node);
197	}
198	public boolean visit(SynchronizedStatement node) {
199	return visitNode(node);
200	}
201	public boolean visit(ThisExpression node) {
202	return visitNode(node);
203	}
204	public boolean visit(ThrowStatement node) {
205	return visitNode(node);
206	}
207	public boolean visit(TryStatement node) {
208	return visitNode(node);
209	}
210	public boolean visit(TypeDeclaration node) {
211	return visitNode(node);
212	}
213	public boolean visit(TypeDeclarationStatement node) {
214	return visitNode(node);
215	}
216	public boolean visit(TypeLiteral node) {
217	return visitNode(node);
218	}
219	public boolean visit(SingleVariableDeclaration node) {
220	return visitNode(node);
221	}
222	public boolean visit(VariableDeclarationExpression node) {
223	return visitNode(node);
224	}
225	public boolean visit(VariableDeclarationStatement node) {
226	return visitNode(node);
227	}
228	public boolean visit(VariableDeclarationFragment node) {
229	return visitNode(node);
230	}
231	public boolean visit(WhileStatement node) {
232	return visitNode(node);
233	}
234
235	/* since 3.0 */
236	public boolean visit(BlockComment node) {
237	return visitNode(node);
238	}
239	public boolean visit(LineComment node) {
240	return visitNode(node);
241	}
242	public boolean visit(MarkerAnnotation node) {
243	return visitNode(node);
244	}
245	public boolean visit(MemberRef node) {
246	return visitNode(node);
247	}
248	public boolean visit(MethodRef node) {
249	return visitNode(node);
250	}
251	public boolean visit(MethodRefParameter node) {
252	return visitNode(node);
253	}
254	public boolean visit(TagElement node) {
255	return visitNode(node);
256	}
257	public boolean visit(TextElement node) {
258	return visitNode(node);
259	}	35	}
260		36
261	public void endVisit(AnonymousClassDeclaration node) {	37	public void endVisit(AnonymousClassDeclaration node) {
Lines 282-287 Link Here
282	public void endVisit(Block node) {	58	public void endVisit(Block node) {
283	endVisitNode(node);	59	endVisitNode(node);
284	}	60	}
		61	/* since 3.0 */
		62	public void endVisit(BlockComment node) {
		63	endVisitNode(node);
		64	}
285	public void endVisit(BooleanLiteral node) {	65	public void endVisit(BooleanLiteral node) {
286	endVisitNode(node);	66	endVisitNode(node);
287	}	67	}
Lines 318-323 Link Here
318	public void endVisit(EmptyStatement node) {	98	public void endVisit(EmptyStatement node) {
319	endVisitNode(node);	99	endVisitNode(node);
320	}	100	}
		101	public void endVisit(EnhancedForStatement node) {
		102	endVisitNode(node);
		103	}
321	public void endVisit(EnumConstantDeclaration node) {	104	public void endVisit(EnumConstantDeclaration node) {
322	endVisitNode(node);	105	endVisitNode(node);
323	}	106	}
Lines 345-354 Link Here
345	public void endVisit(InfixExpression node) {	128	public void endVisit(InfixExpression node) {
346	endVisitNode(node);	129	endVisitNode(node);
347	}	130	}
348	public void endVisit(InstanceofExpression node) {	131	public void endVisit(Initializer node) {
349	endVisitNode(node);	132	endVisitNode(node);
350	}	133	}
351	public void endVisit(Initializer node) {	134	public void endVisit(InstanceofExpression node) {
352	endVisitNode(node);	135	endVisitNode(node);
353	}	136	}
354	public void endVisit(Javadoc node) {	137	public void endVisit(Javadoc node) {
Lines 357-392 Link Here
357	public void endVisit(LabeledStatement node) {	140	public void endVisit(LabeledStatement node) {
358	endVisitNode(node);	141	endVisitNode(node);
359	}	142	}
360	public void endVisit(MethodDeclaration node) {	143	public void endVisit(LineComment node) {
361	endVisitNode(node);	144	endVisitNode(node);
362	}	145	}
363	public void endVisit(MethodInvocation node) {	146	public void endVisit(MarkerAnnotation node) {
364	endVisitNode(node);	147	endVisitNode(node);
365	}	148	}
366	public void endVisit(NullLiteral node) {	149	public void endVisit(MemberRef node) {
367	endVisitNode(node);	150	endVisitNode(node);
368	}	151	}
369	public void endVisit(NumberLiteral node) {	152	public void endVisit(MemberValuePair node) {
370	endVisitNode(node);	153	endVisitNode(node);
371	}	154	}
372	public void endVisit(PackageDeclaration node) {	155	public void endVisit(MethodDeclaration node) {
373	endVisitNode(node);	156	endVisitNode(node);
374	}	157	}
375	public void endVisit(ParenthesizedExpression node) {	158	public void endVisit(MethodInvocation node) {
376	endVisitNode(node);	159	endVisitNode(node);
377	}	160	}
378	public void endVisit(PostfixExpression node) {	161	public void endVisit(MethodRef node) {
379	endVisitNode(node);	162	endVisitNode(node);
380	}	163	}
381	public void endVisit(PrefixExpression node) {	164	public void endVisit(MethodRefParameter node) {
382	endVisitNode(node);	165	endVisitNode(node);
383	}	166	}
384	public void endVisit(PrimitiveType node) {	167	public void endVisit(NormalAnnotation node) {
		168	endVisitNode(node);
		169	}
		170	public void endVisit(NullLiteral node) {
		171	endVisitNode(node);
		172	}
		173	public void endVisit(NumberLiteral node) {
		174	endVisitNode(node);
		175	}
		176	public void endVisit(PackageDeclaration node) {
		177	endVisitNode(node);
		178	}
		179	public void endVisit(ParameterizedType node) {
		180	endVisitNode(node);
		181	}
		182	public void endVisit(ParenthesizedExpression node) {
		183	endVisitNode(node);
		184	}
		185	public void endVisit(PostfixExpression node) {
		186	endVisitNode(node);
		187	}
		188	public void endVisit(PrefixExpression node) {
		189	endVisitNode(node);
		190	}
		191	public void endVisit(PrimitiveType node) {
385	endVisitNode(node);	192	endVisitNode(node);
386	}	193	}
387	public void endVisit(QualifiedName node) {	194	public void endVisit(QualifiedName node) {
388	endVisitNode(node);	195	endVisitNode(node);
389	}	196	}
		197	public void endVisit(QualifiedType node) {
		198	endVisitNode(node);
		199	}
390	public void endVisit(ReturnStatement node) {	200	public void endVisit(ReturnStatement node) {
391	endVisitNode(node);	201	endVisitNode(node);
392	}	202	}
Lines 396-401 Link Here
396	public void endVisit(SimpleType node) {	206	public void endVisit(SimpleType node) {
397	endVisitNode(node);	207	endVisitNode(node);
398	}	208	}
		209	public void endVisit(SingleMemberAnnotation node) {
		210	endVisitNode(node);
		211	}
		212	public void endVisit(SingleVariableDeclaration node) {
		213	endVisitNode(node);
		214	}
399	public void endVisit(StringLiteral node) {	215	public void endVisit(StringLiteral node) {
400	endVisitNode(node);	216	endVisitNode(node);
401	}	217	}
Lines 408-413 Link Here
408	public void endVisit(SuperMethodInvocation node) {	224	public void endVisit(SuperMethodInvocation node) {
409	endVisitNode(node);	225	endVisitNode(node);
410	}	226	}
		227
411	public void endVisit(SwitchCase node) {	228	public void endVisit(SwitchCase node) {
412	endVisitNode(node);	229	endVisitNode(node);
413	}	230	}
Lines 417-422 Link Here
417	public void endVisit(SynchronizedStatement node) {	234	public void endVisit(SynchronizedStatement node) {
418	endVisitNode(node);	235	endVisitNode(node);
419	}	236	}
		237	public void endVisit(TagElement node) {
		238	endVisitNode(node);
		239	}
		240	public void endVisit(TextElement node) {
		241	endVisitNode(node);
		242	}
420	public void endVisit(ThisExpression node) {	243	public void endVisit(ThisExpression node) {
421	endVisitNode(node);	244	endVisitNode(node);
422	}	245	}
Lines 426-431 Link Here
426	public void endVisit(TryStatement node) {	249	public void endVisit(TryStatement node) {
427	endVisitNode(node);	250	endVisitNode(node);
428	}	251	}
		252
429	public void endVisit(TypeDeclaration node) {	253	public void endVisit(TypeDeclaration node) {
430	endVisitNode(node);	254	endVisitNode(node);
431	}	255	}
Lines 435-480 Link Here
435	public void endVisit(TypeLiteral node) {	259	public void endVisit(TypeLiteral node) {
436	endVisitNode(node);	260	endVisitNode(node);
437	}	261	}
438	public void endVisit(SingleVariableDeclaration node) {	262	public void endVisit(TypeParameter node) {
439	endVisitNode(node);	263	endVisitNode(node);
440	}	264	}
441	public void endVisit(VariableDeclarationExpression node) {	265	public void endVisit(VariableDeclarationExpression node) {
442	endVisitNode(node);	266	endVisitNode(node);
443	}	267	}
444	public void endVisit(VariableDeclarationStatement node) {	268	public void endVisit(VariableDeclarationFragment node) {
445	endVisitNode(node);	269	endVisitNode(node);
446	}	270	}
447	public void endVisit(VariableDeclarationFragment node) {	271	public void endVisit(VariableDeclarationStatement node) {
448	endVisitNode(node);	272	endVisitNode(node);
449	}	273	}
450	public void endVisit(WhileStatement node) {	274	public void endVisit(WhileStatement node) {
451	endVisitNode(node);	275	endVisitNode(node);
452	}	276	}
453		277	public void endVisit(WildcardType node) {
454	/* since 3.0 */
455	public void endVisit(BlockComment node) {
456	endVisitNode(node);	278	endVisitNode(node);
457	}	279	}
458	public void endVisit(LineComment node) {	280	protected void endVisitNode(ASTNode node) {
459	endVisitNode(node);	281	// do nothing
460	}	282	}
461	public void endVisit(MarkerAnnotation node) {	283	public boolean visit(AnnotationTypeDeclaration node) {
462	endVisitNode(node);	284	return visitNode(node);
463	}	285	}
464	public void endVisit(MemberRef node) {	286	public boolean visit(AnnotationTypeMemberDeclaration node) {
465	endVisitNode(node);	287	return visitNode(node);
466	}	288	}
467	public void endVisit(MethodRef node) {	289	public boolean visit(AnonymousClassDeclaration node) {
468	endVisitNode(node);	290	return visitNode(node);
469	}	291	}
470	public void endVisit(MethodRefParameter node) {	292	public boolean visit(ArrayAccess node) {
471	endVisitNode(node);	293	return visitNode(node);
472	}	294	}
473	public void endVisit(TagElement node) {	295	public boolean visit(ArrayCreation node) {
474	endVisitNode(node);	296	return visitNode(node);
475	}	297	}
476	public void endVisit(TextElement node) {	298	public boolean visit(ArrayInitializer node) {
477	endVisitNode(node);	299	return visitNode(node);
		300	}
		301	public boolean visit(ArrayType node) {
		302	visitNode(node);
		303	return false;
		304	}
		305	public boolean visit(AssertStatement node) {
		306	return visitNode(node);
		307	}
		308	public boolean visit(Assignment node) {
		309	return visitNode(node);
		310	}
		311	public boolean visit(Block node) {
		312	return visitNode(node);
		313	}
		314	/* since 3.0 */
		315	public boolean visit(BlockComment node) {
		316	return visitNode(node);
		317	}
		318	public boolean visit(BooleanLiteral node) {
		319	return visitNode(node);
		320	}
		321	public boolean visit(BreakStatement node) {
		322	return visitNode(node);
		323	}
		324	public boolean visit(CastExpression node) {
		325	return visitNode(node);
		326	}
		327	public boolean visit(CatchClause node) {
		328	return visitNode(node);
		329	}
		330	public boolean visit(CharacterLiteral node) {
		331	return visitNode(node);
		332	}
		333	public boolean visit(ClassInstanceCreation node) {
		334	return visitNode(node);
		335	}
		336	public boolean visit(CompilationUnit node) {
		337	return visitNode(node);
		338	}
		339	public boolean visit(ConditionalExpression node) {
		340	return visitNode(node);
		341	}
		342	public boolean visit(ConstructorInvocation node) {
		343	return visitNode(node);
		344	}
		345	public boolean visit(ContinueStatement node) {
		346	return visitNode(node);
		347	}
		348	public boolean visit(DoStatement node) {
		349	return visitNode(node);
		350	}
		351	public boolean visit(EmptyStatement node) {
		352	return visitNode(node);
		353	}
		354	public boolean visit(EnhancedForStatement node) {
		355	return visitNode(node);
		356	}
		357	public boolean visit(EnumConstantDeclaration node) {
		358	return visitNode(node);
		359	}
		360	public boolean visit(EnumDeclaration node) {
		361	return visitNode(node);
		362	}
		363	public boolean visit(ExpressionStatement node) {
364	return visitNode(node);
365	}
366	public boolean visit(FieldAccess node) {
367	return visitNode(node);
368	}
369	public boolean visit(FieldDeclaration node) {
370	return visitNode(node);
371	}
372	public boolean visit(ForStatement node) {
373	return visitNode(node);
374	}
375	public boolean visit(IfStatement node) {
376	return visitNode(node);
377	}
378	public boolean visit(ImportDeclaration node) {
379	return visitNode(node);
380	}
381	public boolean visit(InfixExpression node) {
382	return visitNode(node);
383	}
384	public boolean visit(Initializer node) {
385	return visitNode(node);
386	}
387	public boolean visit(InstanceofExpression node) {
388	return visitNode(node);
389	}
390	public boolean visit(Javadoc node) {
391	// do not visit Javadoc tags by default. Use constructor with boolean to enable.
392	if (super.visit(node)) {
393	return visitNode(node);
394	}
395	return false;
396	}
397	public boolean visit(LabeledStatement node) {
398	return visitNode(node);
399	}
400	public boolean visit(LineComment node) {
401	return visitNode(node);
402	}
403	public boolean visit(MarkerAnnotation node) {
404	return visitNode(node);
405	}
406	public boolean visit(MemberRef node) {
407	return visitNode(node);
408	}
409	public boolean visit(MemberValuePair node) {
410	return visitNode(node);
411	}
412	public boolean visit(MethodDeclaration node) {
413	return visitNode(node);
414	}
415	public boolean visit(MethodInvocation node) {
416	return visitNode(node);
417	}
418	public boolean visit(MethodRef node) {
419	return visitNode(node);
420	}
421	public boolean visit(MethodRefParameter node) {
422	return visitNode(node);
423	}
424	public boolean visit(NormalAnnotation node) {
425	return visitNode(node);
426	}
427	public boolean visit(NullLiteral node) {
428	return visitNode(node);
429	}
430	public boolean visit(NumberLiteral node) {
431	return visitNode(node);
432	}
433	public boolean visit(PackageDeclaration node) {
434	return visitNode(node);
435	}
436	public boolean visit(ParameterizedType node) {
437	return visitNode(node);
438	}
439	public boolean visit(ParenthesizedExpression node) {
440	return visitNode(node);
441	}
442	public boolean visit(PostfixExpression node) {
443	return visitNode(node);
444	}
445	public boolean visit(PrefixExpression node) {
446	return visitNode(node);
447	}
448
449	public boolean visit(PrimitiveType node) {
450	return visitNode(node);
451	}
452	public boolean visit(QualifiedName node) {
453	return visitNode(node);
454	}
455	public boolean visit(QualifiedType node) {
456	return visitNode(node);
457	}
458	public boolean visit(ReturnStatement node) {
459	return visitNode(node);
460	}
461	public boolean visit(SimpleName node) {
462	return visitNode(node);
463	}
464	public boolean visit(SimpleType node) {
465	return visitNode(node);
466	}
467	public boolean visit(SingleMemberAnnotation node) {
468	return visitNode(node);
469	}
470	public boolean visit(SingleVariableDeclaration node) {
471	return visitNode(node);
472	}
473
474	public boolean visit(StringLiteral node) {
475	return visitNode(node);
476	}
477
478	public boolean visit(SuperConstructorInvocation node) {
479	return visitNode(node);
480	}
481
482	public boolean visit(SuperFieldAccess node) {
483	return visitNode(node);
484	}
485
486	public boolean visit(SuperMethodInvocation node) {
487	return visitNode(node);
488	}
489
490	public boolean visit(SwitchCase node) {
491	return visitNode(node);
492	}
493
494	public boolean visit(SwitchStatement node) {
495	return visitNode(node);
496	}
497
498	public boolean visit(SynchronizedStatement node) {
499	return visitNode(node);
500	}
501
502	public boolean visit(TagElement node) {
503	return visitNode(node);
504	}
505
506	public boolean visit(TextElement node) {
507	return visitNode(node);
508	}
509
510	public boolean visit(ThisExpression node) {
511	return visitNode(node);
512	}
513
514	public boolean visit(ThrowStatement node) {
515	return visitNode(node);
516	}
517
518	public boolean visit(TryStatement node) {
519	return visitNode(node);
520	}
521
522	public boolean visit(TypeDeclaration node) {
523	return visitNode(node);
524	}
525
526	public boolean visit(TypeDeclarationStatement node) {
527	return visitNode(node);
528	}
529
530	public boolean visit(TypeLiteral node) {
531	return visitNode(node);
532	}
533
534	public boolean visit(TypeParameter node) {
535	return visitNode(node);
536	}
537
538	public boolean visit(VariableDeclarationExpression node) {
539	return visitNode(node);
540	}
541
542	public boolean visit(VariableDeclarationFragment node) {
543	return visitNode(node);
544	}
545
546	public boolean visit(VariableDeclarationStatement node) {
547	return visitNode(node);
548	}
549
550	public boolean visit(WhileStatement node) {
551	return visitNode(node);
552	}
553
554	public boolean visit(WildcardType node) {
555	return visitNode(node);
556	}
557
558	protected boolean visitNode(ASTNode node) {
559	return true;
478	}	560	}
479		561
480	}	562	}