001 package edu.rice.cs.javalanglevels.tree;
002
003 /** A parametric abstract implementation of a visitor over JExpressionIF that return a value.
004 ** This visitor implements the visitor interface with methods that
005 ** first visit children, and then call visitCASEOnly(), passing in
006 ** the values of the visits of the children. (CASE is replaced by the case name.)
007 **/
008 public abstract class JExpressionIFDepthFirstVisitor<RetType> implements JExpressionIFVisitor<RetType> {
009 protected abstract RetType[] makeArrayOfRetType(int len);
010
011 /**
012 * This method is called by default from cases that do not
013 * override forCASEOnly.
014 **/
015 protected abstract RetType defaultCase(JExpressionIF that);
016
017 /* Methods to visit an item. */
018 public RetType forJExpressionOnly(JExpression that) {
019 return defaultCase(that);
020 }
021
022 public RetType forSourceFileOnly(SourceFile that, RetType[] packageStatements_result, RetType[] importStatements_result, RetType[] types_result) {
023 return forJExpressionOnly(that);
024 }
025
026 public RetType forModifiersAndVisibilityOnly(ModifiersAndVisibility that) {
027 return forJExpressionOnly(that);
028 }
029
030 public RetType forCompoundWordOnly(CompoundWord that, RetType[] words_result) {
031 return forJExpressionOnly(that);
032 }
033
034 public RetType forWordOnly(Word that) {
035 return forJExpressionOnly(that);
036 }
037
038 public RetType forTypeDefBaseOnly(TypeDefBase that, RetType mav_result, RetType name_result, RetType[] typeParameters_result, RetType[] interfaces_result, RetType body_result) {
039 return forJExpressionOnly(that);
040 }
041
042 public RetType forClassDefOnly(ClassDef that, RetType mav_result, RetType name_result, RetType[] typeParameters_result, RetType superclass_result, RetType[] interfaces_result, RetType body_result) {
043 return forTypeDefBaseOnly(that, mav_result, name_result, typeParameters_result, interfaces_result, body_result);
044 }
045
046 public RetType forInnerClassDefOnly(InnerClassDef that, RetType mav_result, RetType name_result, RetType[] typeParameters_result, RetType superclass_result, RetType[] interfaces_result, RetType body_result) {
047 return forClassDefOnly(that, mav_result, name_result, typeParameters_result, superclass_result, interfaces_result, body_result);
048 }
049
050 public RetType forInterfaceDefOnly(InterfaceDef that, RetType mav_result, RetType name_result, RetType[] typeParameters_result, RetType[] interfaces_result, RetType body_result) {
051 return forTypeDefBaseOnly(that, mav_result, name_result, typeParameters_result, interfaces_result, body_result);
052 }
053
054 public RetType forInnerInterfaceDefOnly(InnerInterfaceDef that, RetType mav_result, RetType name_result, RetType[] typeParameters_result, RetType[] interfaces_result, RetType body_result) {
055 return forInterfaceDefOnly(that, mav_result, name_result, typeParameters_result, interfaces_result, body_result);
056 }
057
058 public RetType forConstructorDefOnly(ConstructorDef that, RetType name_result, RetType mav_result, RetType[] parameters_result, RetType[] throws_result, RetType statements_result) {
059 return forJExpressionOnly(that);
060 }
061
062 public RetType forInitializerOnly(Initializer that, RetType code_result) {
063 return forJExpressionOnly(that);
064 }
065
066 public RetType forInstanceInitializerOnly(InstanceInitializer that, RetType code_result) {
067 return forInitializerOnly(that, code_result);
068 }
069
070 public RetType forStaticInitializerOnly(StaticInitializer that, RetType code_result) {
071 return forInitializerOnly(that, code_result);
072 }
073
074 public RetType forPackageStatementOnly(PackageStatement that, RetType cWord_result) {
075 return forJExpressionOnly(that);
076 }
077
078 public RetType forImportStatementOnly(ImportStatement that, RetType cWord_result) {
079 return forJExpressionOnly(that);
080 }
081
082 public RetType forClassImportStatementOnly(ClassImportStatement that, RetType cWord_result) {
083 return forImportStatementOnly(that, cWord_result);
084 }
085
086 public RetType forPackageImportStatementOnly(PackageImportStatement that, RetType cWord_result) {
087 return forImportStatementOnly(that, cWord_result);
088 }
089
090 public RetType forStatementOnly(Statement that) {
091 return forJExpressionOnly(that);
092 }
093
094 public RetType forLabeledStatementOnly(LabeledStatement that, RetType label_result, RetType statement_result) {
095 return forStatementOnly(that);
096 }
097
098 public RetType forBlockOnly(Block that, RetType statements_result) {
099 return forStatementOnly(that);
100 }
101
102 public RetType forExpressionStatementOnly(ExpressionStatement that, RetType expression_result) {
103 return forStatementOnly(that);
104 }
105
106 public RetType forSwitchStatementOnly(SwitchStatement that, RetType test_result, RetType[] cases_result) {
107 return forStatementOnly(that);
108 }
109
110 public RetType forIfThenStatementOnly(IfThenStatement that, RetType testExpression_result, RetType thenStatement_result) {
111 return forStatementOnly(that);
112 }
113
114 public RetType forIfThenElseStatementOnly(IfThenElseStatement that, RetType testExpression_result, RetType thenStatement_result, RetType elseStatement_result) {
115 return forIfThenStatementOnly(that, testExpression_result, thenStatement_result);
116 }
117
118 public RetType forWhileStatementOnly(WhileStatement that, RetType condition_result, RetType code_result) {
119 return forStatementOnly(that);
120 }
121
122 public RetType forDoStatementOnly(DoStatement that, RetType code_result, RetType condition_result) {
123 return forStatementOnly(that);
124 }
125
126 public RetType forForStatementOnly(ForStatement that, RetType init_result, RetType condition_result, RetType update_result, RetType code_result) {
127 return forStatementOnly(that);
128 }
129
130 public RetType forBreakStatementOnly(BreakStatement that) {
131 return forStatementOnly(that);
132 }
133
134 public RetType forLabeledBreakStatementOnly(LabeledBreakStatement that, RetType label_result) {
135 return forBreakStatementOnly(that);
136 }
137
138 public RetType forUnlabeledBreakStatementOnly(UnlabeledBreakStatement that) {
139 return forBreakStatementOnly(that);
140 }
141
142 public RetType forContinueStatementOnly(ContinueStatement that) {
143 return forStatementOnly(that);
144 }
145
146 public RetType forLabeledContinueStatementOnly(LabeledContinueStatement that, RetType label_result) {
147 return forContinueStatementOnly(that);
148 }
149
150 public RetType forUnlabeledContinueStatementOnly(UnlabeledContinueStatement that) {
151 return forContinueStatementOnly(that);
152 }
153
154 public RetType forReturnStatementOnly(ReturnStatement that) {
155 return forStatementOnly(that);
156 }
157
158 public RetType forVoidReturnStatementOnly(VoidReturnStatement that) {
159 return forReturnStatementOnly(that);
160 }
161
162 public RetType forValueReturnStatementOnly(ValueReturnStatement that, RetType value_result) {
163 return forReturnStatementOnly(that);
164 }
165
166 public RetType forThrowStatementOnly(ThrowStatement that, RetType thrown_result) {
167 return forStatementOnly(that);
168 }
169
170 public RetType forSynchronizedStatementOnly(SynchronizedStatement that, RetType lockExpr_result, RetType block_result) {
171 return forStatementOnly(that);
172 }
173
174 public RetType forTryCatchStatementOnly(TryCatchStatement that, RetType tryBlock_result, RetType[] catchBlocks_result) {
175 return forStatementOnly(that);
176 }
177
178 public RetType forTryCatchFinallyStatementOnly(TryCatchFinallyStatement that, RetType tryBlock_result, RetType[] catchBlocks_result, RetType finallyBlock_result) {
179 return forTryCatchStatementOnly(that, tryBlock_result, catchBlocks_result);
180 }
181
182 public RetType forNormalTryCatchStatementOnly(NormalTryCatchStatement that, RetType tryBlock_result, RetType[] catchBlocks_result) {
183 return forTryCatchStatementOnly(that, tryBlock_result, catchBlocks_result);
184 }
185
186 public RetType forEmptyStatementOnly(EmptyStatement that) {
187 return forStatementOnly(that);
188 }
189
190 public RetType forMethodDefOnly(MethodDef that, RetType mav_result, RetType[] typeParams_result, RetType result_result, RetType name_result, RetType[] params_result, RetType[] throws_result) {
191 return forJExpressionOnly(that);
192 }
193
194 public RetType forConcreteMethodDefOnly(ConcreteMethodDef that, RetType mav_result, RetType[] typeParams_result, RetType result_result, RetType name_result, RetType[] params_result, RetType[] throws_result, RetType body_result) {
195 return forMethodDefOnly(that, mav_result, typeParams_result, result_result, name_result, params_result, throws_result);
196 }
197
198 public RetType forAbstractMethodDefOnly(AbstractMethodDef that, RetType mav_result, RetType[] typeParams_result, RetType result_result, RetType name_result, RetType[] params_result, RetType[] throws_result) {
199 return forMethodDefOnly(that, mav_result, typeParams_result, result_result, name_result, params_result, throws_result);
200 }
201
202 public RetType forFormalParameterOnly(FormalParameter that, RetType declarator_result) {
203 return forJExpressionOnly(that);
204 }
205
206 public RetType forVariableDeclarationOnly(VariableDeclaration that, RetType mav_result, RetType[] declarators_result) {
207 return forJExpressionOnly(that);
208 }
209
210 public RetType forVariableDeclaratorOnly(VariableDeclarator that, RetType type_result, RetType name_result) {
211 return forJExpressionOnly(that);
212 }
213
214 public RetType forUninitializedVariableDeclaratorOnly(UninitializedVariableDeclarator that, RetType type_result, RetType name_result) {
215 return forVariableDeclaratorOnly(that, type_result, name_result);
216 }
217
218 public RetType forInitializedVariableDeclaratorOnly(InitializedVariableDeclarator that, RetType type_result, RetType name_result, RetType initializer_result) {
219 return forVariableDeclaratorOnly(that, type_result, name_result);
220 }
221
222 public RetType forTypeParameterOnly(TypeParameter that, RetType variable_result, RetType bound_result) {
223 return forJExpressionOnly(that);
224 }
225
226 public RetType forArrayInitializerOnly(ArrayInitializer that, RetType[] items_result) {
227 return forJExpressionOnly(that);
228 }
229
230 public RetType forTypeOnly(Type that) {
231 return forJExpressionOnly(that);
232 }
233
234 public RetType forPrimitiveTypeOnly(PrimitiveType that) {
235 return forTypeOnly(that);
236 }
237
238 public RetType forArrayTypeOnly(ArrayType that, RetType elementType_result) {
239 return forTypeOnly(that);
240 }
241
242 public RetType forReferenceTypeOnly(ReferenceType that) {
243 return forTypeOnly(that);
244 }
245
246 public RetType forMemberTypeOnly(MemberType that, RetType left_result, RetType right_result) {
247 return forReferenceTypeOnly(that);
248 }
249
250 public RetType forClassOrInterfaceTypeOnly(ClassOrInterfaceType that, RetType[] typeArguments_result) {
251 return forReferenceTypeOnly(that);
252 }
253
254 public RetType forTypeVariableOnly(TypeVariable that) {
255 return forReferenceTypeOnly(that);
256 }
257
258 public RetType forVoidReturnOnly(VoidReturn that) {
259 return forJExpressionOnly(that);
260 }
261
262 public RetType forSwitchCaseOnly(SwitchCase that, RetType code_result) {
263 return forJExpressionOnly(that);
264 }
265
266 public RetType forLabeledCaseOnly(LabeledCase that, RetType label_result, RetType code_result) {
267 return forSwitchCaseOnly(that, code_result);
268 }
269
270 public RetType forDefaultCaseOnly(DefaultCase that, RetType code_result) {
271 return forSwitchCaseOnly(that, code_result);
272 }
273
274 public RetType forCatchBlockOnly(CatchBlock that, RetType exception_result, RetType block_result) {
275 return forJExpressionOnly(that);
276 }
277
278 public RetType forExpressionOnly(Expression that) {
279 return forJExpressionOnly(that);
280 }
281
282 public RetType forAssignmentExpressionOnly(AssignmentExpression that, RetType name_result, RetType value_result) {
283 return forExpressionOnly(that);
284 }
285
286 public RetType forSimpleAssignmentExpressionOnly(SimpleAssignmentExpression that, RetType name_result, RetType value_result) {
287 return forAssignmentExpressionOnly(that, name_result, value_result);
288 }
289
290 public RetType forPlusAssignmentExpressionOnly(PlusAssignmentExpression that, RetType name_result, RetType value_result) {
291 return forAssignmentExpressionOnly(that, name_result, value_result);
292 }
293
294 public RetType forNumericAssignmentExpressionOnly(NumericAssignmentExpression that, RetType name_result, RetType value_result) {
295 return forAssignmentExpressionOnly(that, name_result, value_result);
296 }
297
298 public RetType forMinusAssignmentExpressionOnly(MinusAssignmentExpression that, RetType name_result, RetType value_result) {
299 return forNumericAssignmentExpressionOnly(that, name_result, value_result);
300 }
301
302 public RetType forMultiplyAssignmentExpressionOnly(MultiplyAssignmentExpression that, RetType name_result, RetType value_result) {
303 return forNumericAssignmentExpressionOnly(that, name_result, value_result);
304 }
305
306 public RetType forDivideAssignmentExpressionOnly(DivideAssignmentExpression that, RetType name_result, RetType value_result) {
307 return forNumericAssignmentExpressionOnly(that, name_result, value_result);
308 }
309
310 public RetType forModAssignmentExpressionOnly(ModAssignmentExpression that, RetType name_result, RetType value_result) {
311 return forNumericAssignmentExpressionOnly(that, name_result, value_result);
312 }
313
314 public RetType forShiftAssignmentExpressionOnly(ShiftAssignmentExpression that, RetType name_result, RetType value_result) {
315 return forAssignmentExpressionOnly(that, name_result, value_result);
316 }
317
318 public RetType forLeftShiftAssignmentExpressionOnly(LeftShiftAssignmentExpression that, RetType name_result, RetType value_result) {
319 return forShiftAssignmentExpressionOnly(that, name_result, value_result);
320 }
321
322 public RetType forRightSignedShiftAssignmentExpressionOnly(RightSignedShiftAssignmentExpression that, RetType name_result, RetType value_result) {
323 return forShiftAssignmentExpressionOnly(that, name_result, value_result);
324 }
325
326 public RetType forRightUnsignedShiftAssignmentExpressionOnly(RightUnsignedShiftAssignmentExpression that, RetType name_result, RetType value_result) {
327 return forShiftAssignmentExpressionOnly(that, name_result, value_result);
328 }
329
330 public RetType forBitwiseAssignmentExpressionOnly(BitwiseAssignmentExpression that, RetType name_result, RetType value_result) {
331 return forAssignmentExpressionOnly(that, name_result, value_result);
332 }
333
334 public RetType forBitwiseAndAssignmentExpressionOnly(BitwiseAndAssignmentExpression that, RetType name_result, RetType value_result) {
335 return forBitwiseAssignmentExpressionOnly(that, name_result, value_result);
336 }
337
338 public RetType forBitwiseOrAssignmentExpressionOnly(BitwiseOrAssignmentExpression that, RetType name_result, RetType value_result) {
339 return forBitwiseAssignmentExpressionOnly(that, name_result, value_result);
340 }
341
342 public RetType forBitwiseXorAssignmentExpressionOnly(BitwiseXorAssignmentExpression that, RetType name_result, RetType value_result) {
343 return forBitwiseAssignmentExpressionOnly(that, name_result, value_result);
344 }
345
346 public RetType forBinaryExpressionOnly(BinaryExpression that, RetType left_result, RetType right_result) {
347 return forExpressionOnly(that);
348 }
349
350 public RetType forBooleanExpressionOnly(BooleanExpression that, RetType left_result, RetType right_result) {
351 return forBinaryExpressionOnly(that, left_result, right_result);
352 }
353
354 public RetType forOrExpressionOnly(OrExpression that, RetType left_result, RetType right_result) {
355 return forBooleanExpressionOnly(that, left_result, right_result);
356 }
357
358 public RetType forAndExpressionOnly(AndExpression that, RetType left_result, RetType right_result) {
359 return forBooleanExpressionOnly(that, left_result, right_result);
360 }
361
362 public RetType forBitwiseBinaryExpressionOnly(BitwiseBinaryExpression that, RetType left_result, RetType right_result) {
363 return forBinaryExpressionOnly(that, left_result, right_result);
364 }
365
366 public RetType forBitwiseOrExpressionOnly(BitwiseOrExpression that, RetType left_result, RetType right_result) {
367 return forBitwiseBinaryExpressionOnly(that, left_result, right_result);
368 }
369
370 public RetType forBitwiseXorExpressionOnly(BitwiseXorExpression that, RetType left_result, RetType right_result) {
371 return forBitwiseBinaryExpressionOnly(that, left_result, right_result);
372 }
373
374 public RetType forBitwiseAndExpressionOnly(BitwiseAndExpression that, RetType left_result, RetType right_result) {
375 return forBitwiseBinaryExpressionOnly(that, left_result, right_result);
376 }
377
378 public RetType forEqualityExpressionOnly(EqualityExpression that, RetType left_result, RetType right_result) {
379 return forBinaryExpressionOnly(that, left_result, right_result);
380 }
381
382 public RetType forEqualsExpressionOnly(EqualsExpression that, RetType left_result, RetType right_result) {
383 return forEqualityExpressionOnly(that, left_result, right_result);
384 }
385
386 public RetType forNotEqualExpressionOnly(NotEqualExpression that, RetType left_result, RetType right_result) {
387 return forEqualityExpressionOnly(that, left_result, right_result);
388 }
389
390 public RetType forComparisonExpressionOnly(ComparisonExpression that, RetType left_result, RetType right_result) {
391 return forBinaryExpressionOnly(that, left_result, right_result);
392 }
393
394 public RetType forLessThanExpressionOnly(LessThanExpression that, RetType left_result, RetType right_result) {
395 return forComparisonExpressionOnly(that, left_result, right_result);
396 }
397
398 public RetType forLessThanOrEqualExpressionOnly(LessThanOrEqualExpression that, RetType left_result, RetType right_result) {
399 return forComparisonExpressionOnly(that, left_result, right_result);
400 }
401
402 public RetType forGreaterThanExpressionOnly(GreaterThanExpression that, RetType left_result, RetType right_result) {
403 return forComparisonExpressionOnly(that, left_result, right_result);
404 }
405
406 public RetType forGreaterThanOrEqualExpressionOnly(GreaterThanOrEqualExpression that, RetType left_result, RetType right_result) {
407 return forComparisonExpressionOnly(that, left_result, right_result);
408 }
409
410 public RetType forShiftBinaryExpressionOnly(ShiftBinaryExpression that, RetType left_result, RetType right_result) {
411 return forBinaryExpressionOnly(that, left_result, right_result);
412 }
413
414 public RetType forLeftShiftExpressionOnly(LeftShiftExpression that, RetType left_result, RetType right_result) {
415 return forShiftBinaryExpressionOnly(that, left_result, right_result);
416 }
417
418 public RetType forRightSignedShiftExpressionOnly(RightSignedShiftExpression that, RetType left_result, RetType right_result) {
419 return forShiftBinaryExpressionOnly(that, left_result, right_result);
420 }
421
422 public RetType forRightUnsignedShiftExpressionOnly(RightUnsignedShiftExpression that, RetType left_result, RetType right_result) {
423 return forShiftBinaryExpressionOnly(that, left_result, right_result);
424 }
425
426 public RetType forPlusExpressionOnly(PlusExpression that, RetType left_result, RetType right_result) {
427 return forBinaryExpressionOnly(that, left_result, right_result);
428 }
429
430 public RetType forNumericBinaryExpressionOnly(NumericBinaryExpression that, RetType left_result, RetType right_result) {
431 return forBinaryExpressionOnly(that, left_result, right_result);
432 }
433
434 public RetType forMinusExpressionOnly(MinusExpression that, RetType left_result, RetType right_result) {
435 return forNumericBinaryExpressionOnly(that, left_result, right_result);
436 }
437
438 public RetType forMultiplyExpressionOnly(MultiplyExpression that, RetType left_result, RetType right_result) {
439 return forNumericBinaryExpressionOnly(that, left_result, right_result);
440 }
441
442 public RetType forDivideExpressionOnly(DivideExpression that, RetType left_result, RetType right_result) {
443 return forNumericBinaryExpressionOnly(that, left_result, right_result);
444 }
445
446 public RetType forModExpressionOnly(ModExpression that, RetType left_result, RetType right_result) {
447 return forNumericBinaryExpressionOnly(that, left_result, right_result);
448 }
449
450 public RetType forNoOpExpressionOnly(NoOpExpression that, RetType left_result, RetType right_result) {
451 return forBinaryExpressionOnly(that, left_result, right_result);
452 }
453
454 public RetType forUnaryExpressionOnly(UnaryExpression that, RetType value_result) {
455 return forExpressionOnly(that);
456 }
457
458 public RetType forIncrementExpressionOnly(IncrementExpression that, RetType value_result) {
459 return forUnaryExpressionOnly(that, value_result);
460 }
461
462 public RetType forPrefixIncrementExpressionOnly(PrefixIncrementExpression that, RetType value_result) {
463 return forIncrementExpressionOnly(that, value_result);
464 }
465
466 public RetType forPositivePrefixIncrementExpressionOnly(PositivePrefixIncrementExpression that, RetType value_result) {
467 return forPrefixIncrementExpressionOnly(that, value_result);
468 }
469
470 public RetType forNegativePrefixIncrementExpressionOnly(NegativePrefixIncrementExpression that, RetType value_result) {
471 return forPrefixIncrementExpressionOnly(that, value_result);
472 }
473
474 public RetType forPostfixIncrementExpressionOnly(PostfixIncrementExpression that, RetType value_result) {
475 return forIncrementExpressionOnly(that, value_result);
476 }
477
478 public RetType forPositivePostfixIncrementExpressionOnly(PositivePostfixIncrementExpression that, RetType value_result) {
479 return forPostfixIncrementExpressionOnly(that, value_result);
480 }
481
482 public RetType forNegativePostfixIncrementExpressionOnly(NegativePostfixIncrementExpression that, RetType value_result) {
483 return forPostfixIncrementExpressionOnly(that, value_result);
484 }
485
486 public RetType forNumericUnaryExpressionOnly(NumericUnaryExpression that, RetType value_result) {
487 return forUnaryExpressionOnly(that, value_result);
488 }
489
490 public RetType forPositiveExpressionOnly(PositiveExpression that, RetType value_result) {
491 return forNumericUnaryExpressionOnly(that, value_result);
492 }
493
494 public RetType forNegativeExpressionOnly(NegativeExpression that, RetType value_result) {
495 return forNumericUnaryExpressionOnly(that, value_result);
496 }
497
498 public RetType forBitwiseNotExpressionOnly(BitwiseNotExpression that, RetType value_result) {
499 return forUnaryExpressionOnly(that, value_result);
500 }
501
502 public RetType forNotExpressionOnly(NotExpression that, RetType value_result) {
503 return forUnaryExpressionOnly(that, value_result);
504 }
505
506 public RetType forConditionalExpressionOnly(ConditionalExpression that, RetType condition_result, RetType forTrue_result, RetType forFalse_result) {
507 return forExpressionOnly(that);
508 }
509
510 public RetType forInstanceofExpressionOnly(InstanceofExpression that, RetType value_result, RetType type_result) {
511 return forExpressionOnly(that);
512 }
513
514 public RetType forCastExpressionOnly(CastExpression that, RetType type_result, RetType value_result) {
515 return forExpressionOnly(that);
516 }
517
518 public RetType forPrimaryOnly(Primary that) {
519 return forExpressionOnly(that);
520 }
521
522 public RetType forLexicalLiteralOnly(LexicalLiteral that) {
523 return forPrimaryOnly(that);
524 }
525
526 public RetType forIntegerLiteralOnly(IntegerLiteral that) {
527 return forLexicalLiteralOnly(that);
528 }
529
530 public RetType forLongLiteralOnly(LongLiteral that) {
531 return forLexicalLiteralOnly(that);
532 }
533
534 public RetType forDoubleLiteralOnly(DoubleLiteral that) {
535 return forLexicalLiteralOnly(that);
536 }
537
538 public RetType forFloatLiteralOnly(FloatLiteral that) {
539 return forLexicalLiteralOnly(that);
540 }
541
542 public RetType forBooleanLiteralOnly(BooleanLiteral that) {
543 return forLexicalLiteralOnly(that);
544 }
545
546 public RetType forCharLiteralOnly(CharLiteral that) {
547 return forLexicalLiteralOnly(that);
548 }
549
550 public RetType forStringLiteralOnly(StringLiteral that) {
551 return forLexicalLiteralOnly(that);
552 }
553
554 public RetType forNullLiteralOnly(NullLiteral that) {
555 return forLexicalLiteralOnly(that);
556 }
557
558 public RetType forInstantiationOnly(Instantiation that) {
559 return forPrimaryOnly(that);
560 }
561
562 public RetType forClassInstantiationOnly(ClassInstantiation that, RetType type_result, RetType arguments_result) {
563 return forInstantiationOnly(that);
564 }
565
566 public RetType forNamedClassInstantiationOnly(NamedClassInstantiation that, RetType type_result, RetType arguments_result) {
567 return forClassInstantiationOnly(that, type_result, arguments_result);
568 }
569
570 public RetType forSimpleNamedClassInstantiationOnly(SimpleNamedClassInstantiation that, RetType type_result, RetType arguments_result) {
571 return forNamedClassInstantiationOnly(that, type_result, arguments_result);
572 }
573
574 public RetType forComplexNamedClassInstantiationOnly(ComplexNamedClassInstantiation that, RetType enclosing_result, RetType type_result, RetType arguments_result) {
575 return forNamedClassInstantiationOnly(that, type_result, arguments_result);
576 }
577
578 public RetType forAnonymousClassInstantiationOnly(AnonymousClassInstantiation that, RetType type_result, RetType arguments_result, RetType body_result) {
579 return forClassInstantiationOnly(that, type_result, arguments_result);
580 }
581
582 public RetType forSimpleAnonymousClassInstantiationOnly(SimpleAnonymousClassInstantiation that, RetType type_result, RetType arguments_result, RetType body_result) {
583 return forAnonymousClassInstantiationOnly(that, type_result, arguments_result, body_result);
584 }
585
586 public RetType forComplexAnonymousClassInstantiationOnly(ComplexAnonymousClassInstantiation that, RetType enclosing_result, RetType type_result, RetType arguments_result, RetType body_result) {
587 return forAnonymousClassInstantiationOnly(that, type_result, arguments_result, body_result);
588 }
589
590 public RetType forArrayInstantiationOnly(ArrayInstantiation that, RetType type_result) {
591 return forInstantiationOnly(that);
592 }
593
594 public RetType forUninitializedArrayInstantiationOnly(UninitializedArrayInstantiation that, RetType type_result, RetType dimensionSizes_result) {
595 return forArrayInstantiationOnly(that, type_result);
596 }
597
598 public RetType forSimpleUninitializedArrayInstantiationOnly(SimpleUninitializedArrayInstantiation that, RetType type_result, RetType dimensionSizes_result) {
599 return forUninitializedArrayInstantiationOnly(that, type_result, dimensionSizes_result);
600 }
601
602 public RetType forComplexUninitializedArrayInstantiationOnly(ComplexUninitializedArrayInstantiation that, RetType enclosing_result, RetType type_result, RetType dimensionSizes_result) {
603 return forUninitializedArrayInstantiationOnly(that, type_result, dimensionSizes_result);
604 }
605
606 public RetType forInitializedArrayInstantiationOnly(InitializedArrayInstantiation that, RetType type_result, RetType initializer_result) {
607 return forArrayInstantiationOnly(that, type_result);
608 }
609
610 public RetType forSimpleInitializedArrayInstantiationOnly(SimpleInitializedArrayInstantiation that, RetType type_result, RetType initializer_result) {
611 return forInitializedArrayInstantiationOnly(that, type_result, initializer_result);
612 }
613
614 public RetType forComplexInitializedArrayInstantiationOnly(ComplexInitializedArrayInstantiation that, RetType enclosing_result, RetType type_result, RetType initializer_result) {
615 return forInitializedArrayInstantiationOnly(that, type_result, initializer_result);
616 }
617
618 public RetType forVariableReferenceOnly(VariableReference that) {
619 return forPrimaryOnly(that);
620 }
621
622 public RetType forNameReferenceOnly(NameReference that, RetType name_result) {
623 return forVariableReferenceOnly(that);
624 }
625
626 public RetType forSimpleNameReferenceOnly(SimpleNameReference that, RetType name_result) {
627 return forNameReferenceOnly(that, name_result);
628 }
629
630 public RetType forComplexNameReferenceOnly(ComplexNameReference that, RetType enclosing_result, RetType name_result) {
631 return forNameReferenceOnly(that, name_result);
632 }
633
634 public RetType forThisReferenceOnly(ThisReference that) {
635 return forVariableReferenceOnly(that);
636 }
637
638 public RetType forSimpleThisReferenceOnly(SimpleThisReference that) {
639 return forThisReferenceOnly(that);
640 }
641
642 public RetType forComplexThisReferenceOnly(ComplexThisReference that, RetType enclosing_result) {
643 return forThisReferenceOnly(that);
644 }
645
646 public RetType forSuperReferenceOnly(SuperReference that) {
647 return forVariableReferenceOnly(that);
648 }
649
650 public RetType forSimpleSuperReferenceOnly(SimpleSuperReference that) {
651 return forSuperReferenceOnly(that);
652 }
653
654 public RetType forComplexSuperReferenceOnly(ComplexSuperReference that, RetType enclosing_result) {
655 return forSuperReferenceOnly(that);
656 }
657
658 public RetType forFunctionInvocationOnly(FunctionInvocation that, RetType arguments_result) {
659 return forPrimaryOnly(that);
660 }
661
662 public RetType forMethodInvocationOnly(MethodInvocation that, RetType arguments_result, RetType name_result) {
663 return forFunctionInvocationOnly(that, arguments_result);
664 }
665
666 public RetType forSimpleMethodInvocationOnly(SimpleMethodInvocation that, RetType name_result, RetType arguments_result) {
667 return forMethodInvocationOnly(that, arguments_result, name_result);
668 }
669
670 public RetType forComplexMethodInvocationOnly(ComplexMethodInvocation that, RetType enclosing_result, RetType name_result, RetType arguments_result) {
671 return forMethodInvocationOnly(that, arguments_result, name_result);
672 }
673
674 public RetType forThisConstructorInvocationOnly(ThisConstructorInvocation that, RetType arguments_result) {
675 return forFunctionInvocationOnly(that, arguments_result);
676 }
677
678 public RetType forSimpleThisConstructorInvocationOnly(SimpleThisConstructorInvocation that, RetType arguments_result) {
679 return forThisConstructorInvocationOnly(that, arguments_result);
680 }
681
682 public RetType forComplexThisConstructorInvocationOnly(ComplexThisConstructorInvocation that, RetType enclosing_result, RetType arguments_result) {
683 return forThisConstructorInvocationOnly(that, arguments_result);
684 }
685
686 public RetType forSuperConstructorInvocationOnly(SuperConstructorInvocation that, RetType arguments_result) {
687 return forFunctionInvocationOnly(that, arguments_result);
688 }
689
690 public RetType forSimpleSuperConstructorInvocationOnly(SimpleSuperConstructorInvocation that, RetType arguments_result) {
691 return forSuperConstructorInvocationOnly(that, arguments_result);
692 }
693
694 public RetType forComplexSuperConstructorInvocationOnly(ComplexSuperConstructorInvocation that, RetType enclosing_result, RetType arguments_result) {
695 return forSuperConstructorInvocationOnly(that, arguments_result);
696 }
697
698 public RetType forClassLiteralOnly(ClassLiteral that, RetType type_result) {
699 return forPrimaryOnly(that);
700 }
701
702 public RetType forArrayAccessOnly(ArrayAccess that, RetType array_result, RetType index_result) {
703 return forPrimaryOnly(that);
704 }
705
706 public RetType forParenthesizedOnly(Parenthesized that, RetType value_result) {
707 return forPrimaryOnly(that);
708 }
709
710 public RetType forEmptyExpressionOnly(EmptyExpression that) {
711 return forPrimaryOnly(that);
712 }
713
714 public RetType forBodyOnly(Body that, RetType[] statements_result) {
715 return forJExpressionOnly(that);
716 }
717
718 public RetType forBracedBodyOnly(BracedBody that, RetType[] statements_result) {
719 return forBodyOnly(that, statements_result);
720 }
721
722 public RetType forUnbracedBodyOnly(UnbracedBody that, RetType[] statements_result) {
723 return forBodyOnly(that, statements_result);
724 }
725
726 public RetType forExpressionListOnly(ExpressionList that, RetType[] expressions_result) {
727 return forJExpressionOnly(that);
728 }
729
730 public RetType forParenthesizedExpressionListOnly(ParenthesizedExpressionList that, RetType[] expressions_result) {
731 return forExpressionListOnly(that, expressions_result);
732 }
733
734 public RetType forUnparenthesizedExpressionListOnly(UnparenthesizedExpressionList that, RetType[] expressions_result) {
735 return forExpressionListOnly(that, expressions_result);
736 }
737
738 public RetType forDimensionExpressionListOnly(DimensionExpressionList that, RetType[] expressions_result) {
739 return forExpressionListOnly(that, expressions_result);
740 }
741
742 public RetType forEmptyForConditionOnly(EmptyForCondition that) {
743 return forJExpressionOnly(that);
744 }
745
746
747 /** Implementation of JExpressionIFVisitor methods to implement depth-first traversal. */
748 public RetType forSourceFile(SourceFile that) {
749 final RetType[] packageStatements_result = makeArrayOfRetType(that.getPackageStatements().length);
750 for (int i = 0; i < that.getPackageStatements().length; i++) {
751 packageStatements_result[i] = that.getPackageStatements()[i].visit(this);
752 }
753 final RetType[] importStatements_result = makeArrayOfRetType(that.getImportStatements().length);
754 for (int i = 0; i < that.getImportStatements().length; i++) {
755 importStatements_result[i] = that.getImportStatements()[i].visit(this);
756 }
757 final RetType[] types_result = makeArrayOfRetType(that.getTypes().length);
758 for (int i = 0; i < that.getTypes().length; i++) {
759 types_result[i] = that.getTypes()[i].visit(this);
760 }
761 return forSourceFileOnly(that, packageStatements_result, importStatements_result, types_result);
762 }
763
764 public RetType forModifiersAndVisibility(ModifiersAndVisibility that) {
765 return forModifiersAndVisibilityOnly(that);
766 }
767
768 public RetType forCompoundWord(CompoundWord that) {
769 final RetType[] words_result = makeArrayOfRetType(that.getWords().length);
770 for (int i = 0; i < that.getWords().length; i++) {
771 words_result[i] = that.getWords()[i].visit(this);
772 }
773 return forCompoundWordOnly(that, words_result);
774 }
775
776 public RetType forWord(Word that) {
777 return forWordOnly(that);
778 }
779
780 public RetType forClassDef(ClassDef that) {
781 final RetType mav_result = that.getMav().visit(this);
782 final RetType name_result = that.getName().visit(this);
783 final RetType[] typeParameters_result = makeArrayOfRetType(that.getTypeParameters().length);
784 for (int i = 0; i < that.getTypeParameters().length; i++) {
785 typeParameters_result[i] = that.getTypeParameters()[i].visit(this);
786 }
787 final RetType superclass_result = that.getSuperclass().visit(this);
788 final RetType[] interfaces_result = makeArrayOfRetType(that.getInterfaces().length);
789 for (int i = 0; i < that.getInterfaces().length; i++) {
790 interfaces_result[i] = that.getInterfaces()[i].visit(this);
791 }
792 final RetType body_result = that.getBody().visit(this);
793 return forClassDefOnly(that, mav_result, name_result, typeParameters_result, superclass_result, interfaces_result, body_result);
794 }
795
796 public RetType forInnerClassDef(InnerClassDef that) {
797 final RetType mav_result = that.getMav().visit(this);
798 final RetType name_result = that.getName().visit(this);
799 final RetType[] typeParameters_result = makeArrayOfRetType(that.getTypeParameters().length);
800 for (int i = 0; i < that.getTypeParameters().length; i++) {
801 typeParameters_result[i] = that.getTypeParameters()[i].visit(this);
802 }
803 final RetType superclass_result = that.getSuperclass().visit(this);
804 final RetType[] interfaces_result = makeArrayOfRetType(that.getInterfaces().length);
805 for (int i = 0; i < that.getInterfaces().length; i++) {
806 interfaces_result[i] = that.getInterfaces()[i].visit(this);
807 }
808 final RetType body_result = that.getBody().visit(this);
809 return forInnerClassDefOnly(that, mav_result, name_result, typeParameters_result, superclass_result, interfaces_result, body_result);
810 }
811
812 public RetType forInterfaceDef(InterfaceDef that) {
813 final RetType mav_result = that.getMav().visit(this);
814 final RetType name_result = that.getName().visit(this);
815 final RetType[] typeParameters_result = makeArrayOfRetType(that.getTypeParameters().length);
816 for (int i = 0; i < that.getTypeParameters().length; i++) {
817 typeParameters_result[i] = that.getTypeParameters()[i].visit(this);
818 }
819 final RetType[] interfaces_result = makeArrayOfRetType(that.getInterfaces().length);
820 for (int i = 0; i < that.getInterfaces().length; i++) {
821 interfaces_result[i] = that.getInterfaces()[i].visit(this);
822 }
823 final RetType body_result = that.getBody().visit(this);
824 return forInterfaceDefOnly(that, mav_result, name_result, typeParameters_result, interfaces_result, body_result);
825 }
826
827 public RetType forInnerInterfaceDef(InnerInterfaceDef that) {
828 final RetType mav_result = that.getMav().visit(this);
829 final RetType name_result = that.getName().visit(this);
830 final RetType[] typeParameters_result = makeArrayOfRetType(that.getTypeParameters().length);
831 for (int i = 0; i < that.getTypeParameters().length; i++) {
832 typeParameters_result[i] = that.getTypeParameters()[i].visit(this);
833 }
834 final RetType[] interfaces_result = makeArrayOfRetType(that.getInterfaces().length);
835 for (int i = 0; i < that.getInterfaces().length; i++) {
836 interfaces_result[i] = that.getInterfaces()[i].visit(this);
837 }
838 final RetType body_result = that.getBody().visit(this);
839 return forInnerInterfaceDefOnly(that, mav_result, name_result, typeParameters_result, interfaces_result, body_result);
840 }
841
842 public RetType forConstructorDef(ConstructorDef that) {
843 final RetType name_result = that.getName().visit(this);
844 final RetType mav_result = that.getMav().visit(this);
845 final RetType[] parameters_result = makeArrayOfRetType(that.getParameters().length);
846 for (int i = 0; i < that.getParameters().length; i++) {
847 parameters_result[i] = that.getParameters()[i].visit(this);
848 }
849 final RetType[] throws_result = makeArrayOfRetType(that.getThrows().length);
850 for (int i = 0; i < that.getThrows().length; i++) {
851 throws_result[i] = that.getThrows()[i].visit(this);
852 }
853 final RetType statements_result = that.getStatements().visit(this);
854 return forConstructorDefOnly(that, name_result, mav_result, parameters_result, throws_result, statements_result);
855 }
856
857 public RetType forInstanceInitializer(InstanceInitializer that) {
858 final RetType code_result = that.getCode().visit(this);
859 return forInstanceInitializerOnly(that, code_result);
860 }
861
862 public RetType forStaticInitializer(StaticInitializer that) {
863 final RetType code_result = that.getCode().visit(this);
864 return forStaticInitializerOnly(that, code_result);
865 }
866
867 public RetType forPackageStatement(PackageStatement that) {
868 final RetType cWord_result = that.getCWord().visit(this);
869 return forPackageStatementOnly(that, cWord_result);
870 }
871
872 public RetType forClassImportStatement(ClassImportStatement that) {
873 final RetType cWord_result = that.getCWord().visit(this);
874 return forClassImportStatementOnly(that, cWord_result);
875 }
876
877 public RetType forPackageImportStatement(PackageImportStatement that) {
878 final RetType cWord_result = that.getCWord().visit(this);
879 return forPackageImportStatementOnly(that, cWord_result);
880 }
881
882 public RetType forLabeledStatement(LabeledStatement that) {
883 final RetType label_result = that.getLabel().visit(this);
884 final RetType statement_result = that.getStatement().visit(this);
885 return forLabeledStatementOnly(that, label_result, statement_result);
886 }
887
888 public RetType forBlock(Block that) {
889 final RetType statements_result = that.getStatements().visit(this);
890 return forBlockOnly(that, statements_result);
891 }
892
893 public RetType forExpressionStatement(ExpressionStatement that) {
894 final RetType expression_result = that.getExpression().visit(this);
895 return forExpressionStatementOnly(that, expression_result);
896 }
897
898 public RetType forSwitchStatement(SwitchStatement that) {
899 final RetType test_result = that.getTest().visit(this);
900 final RetType[] cases_result = makeArrayOfRetType(that.getCases().length);
901 for (int i = 0; i < that.getCases().length; i++) {
902 cases_result[i] = that.getCases()[i].visit(this);
903 }
904 return forSwitchStatementOnly(that, test_result, cases_result);
905 }
906
907 public RetType forIfThenStatement(IfThenStatement that) {
908 final RetType testExpression_result = that.getTestExpression().visit(this);
909 final RetType thenStatement_result = that.getThenStatement().visit(this);
910 return forIfThenStatementOnly(that, testExpression_result, thenStatement_result);
911 }
912
913 public RetType forIfThenElseStatement(IfThenElseStatement that) {
914 final RetType testExpression_result = that.getTestExpression().visit(this);
915 final RetType thenStatement_result = that.getThenStatement().visit(this);
916 final RetType elseStatement_result = that.getElseStatement().visit(this);
917 return forIfThenElseStatementOnly(that, testExpression_result, thenStatement_result, elseStatement_result);
918 }
919
920 public RetType forWhileStatement(WhileStatement that) {
921 final RetType condition_result = that.getCondition().visit(this);
922 final RetType code_result = that.getCode().visit(this);
923 return forWhileStatementOnly(that, condition_result, code_result);
924 }
925
926 public RetType forDoStatement(DoStatement that) {
927 final RetType code_result = that.getCode().visit(this);
928 final RetType condition_result = that.getCondition().visit(this);
929 return forDoStatementOnly(that, code_result, condition_result);
930 }
931
932 public RetType forForStatement(ForStatement that) {
933 final RetType init_result = that.getInit().visit(this);
934 final RetType condition_result = that.getCondition().visit(this);
935 final RetType update_result = that.getUpdate().visit(this);
936 final RetType code_result = that.getCode().visit(this);
937 return forForStatementOnly(that, init_result, condition_result, update_result, code_result);
938 }
939
940 public RetType forLabeledBreakStatement(LabeledBreakStatement that) {
941 final RetType label_result = that.getLabel().visit(this);
942 return forLabeledBreakStatementOnly(that, label_result);
943 }
944
945 public RetType forUnlabeledBreakStatement(UnlabeledBreakStatement that) {
946 return forUnlabeledBreakStatementOnly(that);
947 }
948
949 public RetType forLabeledContinueStatement(LabeledContinueStatement that) {
950 final RetType label_result = that.getLabel().visit(this);
951 return forLabeledContinueStatementOnly(that, label_result);
952 }
953
954 public RetType forUnlabeledContinueStatement(UnlabeledContinueStatement that) {
955 return forUnlabeledContinueStatementOnly(that);
956 }
957
958 public RetType forVoidReturnStatement(VoidReturnStatement that) {
959 return forVoidReturnStatementOnly(that);
960 }
961
962 public RetType forValueReturnStatement(ValueReturnStatement that) {
963 final RetType value_result = that.getValue().visit(this);
964 return forValueReturnStatementOnly(that, value_result);
965 }
966
967 public RetType forThrowStatement(ThrowStatement that) {
968 final RetType thrown_result = that.getThrown().visit(this);
969 return forThrowStatementOnly(that, thrown_result);
970 }
971
972 public RetType forSynchronizedStatement(SynchronizedStatement that) {
973 final RetType lockExpr_result = that.getLockExpr().visit(this);
974 final RetType block_result = that.getBlock().visit(this);
975 return forSynchronizedStatementOnly(that, lockExpr_result, block_result);
976 }
977
978 public RetType forTryCatchFinallyStatement(TryCatchFinallyStatement that) {
979 final RetType tryBlock_result = that.getTryBlock().visit(this);
980 final RetType[] catchBlocks_result = makeArrayOfRetType(that.getCatchBlocks().length);
981 for (int i = 0; i < that.getCatchBlocks().length; i++) {
982 catchBlocks_result[i] = that.getCatchBlocks()[i].visit(this);
983 }
984 final RetType finallyBlock_result = that.getFinallyBlock().visit(this);
985 return forTryCatchFinallyStatementOnly(that, tryBlock_result, catchBlocks_result, finallyBlock_result);
986 }
987
988 public RetType forNormalTryCatchStatement(NormalTryCatchStatement that) {
989 final RetType tryBlock_result = that.getTryBlock().visit(this);
990 final RetType[] catchBlocks_result = makeArrayOfRetType(that.getCatchBlocks().length);
991 for (int i = 0; i < that.getCatchBlocks().length; i++) {
992 catchBlocks_result[i] = that.getCatchBlocks()[i].visit(this);
993 }
994 return forNormalTryCatchStatementOnly(that, tryBlock_result, catchBlocks_result);
995 }
996
997 public RetType forEmptyStatement(EmptyStatement that) {
998 return forEmptyStatementOnly(that);
999 }
1000
1001 public RetType forConcreteMethodDef(ConcreteMethodDef that) {
1002 final RetType mav_result = that.getMav().visit(this);
1003 final RetType[] typeParams_result = makeArrayOfRetType(that.getTypeParams().length);
1004 for (int i = 0; i < that.getTypeParams().length; i++) {
1005 typeParams_result[i] = that.getTypeParams()[i].visit(this);
1006 }
1007 final RetType result_result = that.getResult().visit(this);
1008 final RetType name_result = that.getName().visit(this);
1009 final RetType[] params_result = makeArrayOfRetType(that.getParams().length);
1010 for (int i = 0; i < that.getParams().length; i++) {
1011 params_result[i] = that.getParams()[i].visit(this);
1012 }
1013 final RetType[] throws_result = makeArrayOfRetType(that.getThrows().length);
1014 for (int i = 0; i < that.getThrows().length; i++) {
1015 throws_result[i] = that.getThrows()[i].visit(this);
1016 }
1017 final RetType body_result = that.getBody().visit(this);
1018 return forConcreteMethodDefOnly(that, mav_result, typeParams_result, result_result, name_result, params_result, throws_result, body_result);
1019 }
1020
1021 public RetType forAbstractMethodDef(AbstractMethodDef that) {
1022 final RetType mav_result = that.getMav().visit(this);
1023 final RetType[] typeParams_result = makeArrayOfRetType(that.getTypeParams().length);
1024 for (int i = 0; i < that.getTypeParams().length; i++) {
1025 typeParams_result[i] = that.getTypeParams()[i].visit(this);
1026 }
1027 final RetType result_result = that.getResult().visit(this);
1028 final RetType name_result = that.getName().visit(this);
1029 final RetType[] params_result = makeArrayOfRetType(that.getParams().length);
1030 for (int i = 0; i < that.getParams().length; i++) {
1031 params_result[i] = that.getParams()[i].visit(this);
1032 }
1033 final RetType[] throws_result = makeArrayOfRetType(that.getThrows().length);
1034 for (int i = 0; i < that.getThrows().length; i++) {
1035 throws_result[i] = that.getThrows()[i].visit(this);
1036 }
1037 return forAbstractMethodDefOnly(that, mav_result, typeParams_result, result_result, name_result, params_result, throws_result);
1038 }
1039
1040 public RetType forFormalParameter(FormalParameter that) {
1041 final RetType declarator_result = that.getDeclarator().visit(this);
1042 return forFormalParameterOnly(that, declarator_result);
1043 }
1044
1045 public RetType forVariableDeclaration(VariableDeclaration that) {
1046 final RetType mav_result = that.getMav().visit(this);
1047 final RetType[] declarators_result = makeArrayOfRetType(that.getDeclarators().length);
1048 for (int i = 0; i < that.getDeclarators().length; i++) {
1049 declarators_result[i] = that.getDeclarators()[i].visit(this);
1050 }
1051 return forVariableDeclarationOnly(that, mav_result, declarators_result);
1052 }
1053
1054 public RetType forUninitializedVariableDeclarator(UninitializedVariableDeclarator that) {
1055 final RetType type_result = that.getType().visit(this);
1056 final RetType name_result = that.getName().visit(this);
1057 return forUninitializedVariableDeclaratorOnly(that, type_result, name_result);
1058 }
1059
1060 public RetType forInitializedVariableDeclarator(InitializedVariableDeclarator that) {
1061 final RetType type_result = that.getType().visit(this);
1062 final RetType name_result = that.getName().visit(this);
1063 final RetType initializer_result = that.getInitializer().visit(this);
1064 return forInitializedVariableDeclaratorOnly(that, type_result, name_result, initializer_result);
1065 }
1066
1067 public RetType forTypeParameter(TypeParameter that) {
1068 final RetType variable_result = that.getVariable().visit(this);
1069 final RetType bound_result = that.getBound().visit(this);
1070 return forTypeParameterOnly(that, variable_result, bound_result);
1071 }
1072
1073 public RetType forArrayInitializer(ArrayInitializer that) {
1074 final RetType[] items_result = makeArrayOfRetType(that.getItems().length);
1075 for (int i = 0; i < that.getItems().length; i++) {
1076 items_result[i] = that.getItems()[i].visit(this);
1077 }
1078 return forArrayInitializerOnly(that, items_result);
1079 }
1080
1081 public RetType forPrimitiveType(PrimitiveType that) {
1082 return forPrimitiveTypeOnly(that);
1083 }
1084
1085 public RetType forArrayType(ArrayType that) {
1086 final RetType elementType_result = that.getElementType().visit(this);
1087 return forArrayTypeOnly(that, elementType_result);
1088 }
1089
1090 public RetType forMemberType(MemberType that) {
1091 final RetType left_result = that.getLeft().visit(this);
1092 final RetType right_result = that.getRight().visit(this);
1093 return forMemberTypeOnly(that, left_result, right_result);
1094 }
1095
1096 public RetType forClassOrInterfaceType(ClassOrInterfaceType that) {
1097 final RetType[] typeArguments_result = makeArrayOfRetType(that.getTypeArguments().length);
1098 for (int i = 0; i < that.getTypeArguments().length; i++) {
1099 typeArguments_result[i] = that.getTypeArguments()[i].visit(this);
1100 }
1101 return forClassOrInterfaceTypeOnly(that, typeArguments_result);
1102 }
1103
1104 public RetType forTypeVariable(TypeVariable that) {
1105 return forTypeVariableOnly(that);
1106 }
1107
1108 public RetType forVoidReturn(VoidReturn that) {
1109 return forVoidReturnOnly(that);
1110 }
1111
1112 public RetType forLabeledCase(LabeledCase that) {
1113 final RetType label_result = that.getLabel().visit(this);
1114 final RetType code_result = that.getCode().visit(this);
1115 return forLabeledCaseOnly(that, label_result, code_result);
1116 }
1117
1118 public RetType forDefaultCase(DefaultCase that) {
1119 final RetType code_result = that.getCode().visit(this);
1120 return forDefaultCaseOnly(that, code_result);
1121 }
1122
1123 public RetType forCatchBlock(CatchBlock that) {
1124 final RetType exception_result = that.getException().visit(this);
1125 final RetType block_result = that.getBlock().visit(this);
1126 return forCatchBlockOnly(that, exception_result, block_result);
1127 }
1128
1129 public RetType forSimpleAssignmentExpression(SimpleAssignmentExpression that) {
1130 final RetType name_result = that.getName().visit(this);
1131 final RetType value_result = that.getValue().visit(this);
1132 return forSimpleAssignmentExpressionOnly(that, name_result, value_result);
1133 }
1134
1135 public RetType forPlusAssignmentExpression(PlusAssignmentExpression that) {
1136 final RetType name_result = that.getName().visit(this);
1137 final RetType value_result = that.getValue().visit(this);
1138 return forPlusAssignmentExpressionOnly(that, name_result, value_result);
1139 }
1140
1141 public RetType forMinusAssignmentExpression(MinusAssignmentExpression that) {
1142 final RetType name_result = that.getName().visit(this);
1143 final RetType value_result = that.getValue().visit(this);
1144 return forMinusAssignmentExpressionOnly(that, name_result, value_result);
1145 }
1146
1147 public RetType forMultiplyAssignmentExpression(MultiplyAssignmentExpression that) {
1148 final RetType name_result = that.getName().visit(this);
1149 final RetType value_result = that.getValue().visit(this);
1150 return forMultiplyAssignmentExpressionOnly(that, name_result, value_result);
1151 }
1152
1153 public RetType forDivideAssignmentExpression(DivideAssignmentExpression that) {
1154 final RetType name_result = that.getName().visit(this);
1155 final RetType value_result = that.getValue().visit(this);
1156 return forDivideAssignmentExpressionOnly(that, name_result, value_result);
1157 }
1158
1159 public RetType forModAssignmentExpression(ModAssignmentExpression that) {
1160 final RetType name_result = that.getName().visit(this);
1161 final RetType value_result = that.getValue().visit(this);
1162 return forModAssignmentExpressionOnly(that, name_result, value_result);
1163 }
1164
1165 public RetType forLeftShiftAssignmentExpression(LeftShiftAssignmentExpression that) {
1166 final RetType name_result = that.getName().visit(this);
1167 final RetType value_result = that.getValue().visit(this);
1168 return forLeftShiftAssignmentExpressionOnly(that, name_result, value_result);
1169 }
1170
1171 public RetType forRightSignedShiftAssignmentExpression(RightSignedShiftAssignmentExpression that) {
1172 final RetType name_result = that.getName().visit(this);
1173 final RetType value_result = that.getValue().visit(this);
1174 return forRightSignedShiftAssignmentExpressionOnly(that, name_result, value_result);
1175 }
1176
1177 public RetType forRightUnsignedShiftAssignmentExpression(RightUnsignedShiftAssignmentExpression that) {
1178 final RetType name_result = that.getName().visit(this);
1179 final RetType value_result = that.getValue().visit(this);
1180 return forRightUnsignedShiftAssignmentExpressionOnly(that, name_result, value_result);
1181 }
1182
1183 public RetType forBitwiseAndAssignmentExpression(BitwiseAndAssignmentExpression that) {
1184 final RetType name_result = that.getName().visit(this);
1185 final RetType value_result = that.getValue().visit(this);
1186 return forBitwiseAndAssignmentExpressionOnly(that, name_result, value_result);
1187 }
1188
1189 public RetType forBitwiseOrAssignmentExpression(BitwiseOrAssignmentExpression that) {
1190 final RetType name_result = that.getName().visit(this);
1191 final RetType value_result = that.getValue().visit(this);
1192 return forBitwiseOrAssignmentExpressionOnly(that, name_result, value_result);
1193 }
1194
1195 public RetType forBitwiseXorAssignmentExpression(BitwiseXorAssignmentExpression that) {
1196 final RetType name_result = that.getName().visit(this);
1197 final RetType value_result = that.getValue().visit(this);
1198 return forBitwiseXorAssignmentExpressionOnly(that, name_result, value_result);
1199 }
1200
1201 public RetType forOrExpression(OrExpression that) {
1202 final RetType left_result = that.getLeft().visit(this);
1203 final RetType right_result = that.getRight().visit(this);
1204 return forOrExpressionOnly(that, left_result, right_result);
1205 }
1206
1207 public RetType forAndExpression(AndExpression that) {
1208 final RetType left_result = that.getLeft().visit(this);
1209 final RetType right_result = that.getRight().visit(this);
1210 return forAndExpressionOnly(that, left_result, right_result);
1211 }
1212
1213 public RetType forBitwiseOrExpression(BitwiseOrExpression that) {
1214 final RetType left_result = that.getLeft().visit(this);
1215 final RetType right_result = that.getRight().visit(this);
1216 return forBitwiseOrExpressionOnly(that, left_result, right_result);
1217 }
1218
1219 public RetType forBitwiseXorExpression(BitwiseXorExpression that) {
1220 final RetType left_result = that.getLeft().visit(this);
1221 final RetType right_result = that.getRight().visit(this);
1222 return forBitwiseXorExpressionOnly(that, left_result, right_result);
1223 }
1224
1225 public RetType forBitwiseAndExpression(BitwiseAndExpression that) {
1226 final RetType left_result = that.getLeft().visit(this);
1227 final RetType right_result = that.getRight().visit(this);
1228 return forBitwiseAndExpressionOnly(that, left_result, right_result);
1229 }
1230
1231 public RetType forEqualsExpression(EqualsExpression that) {
1232 final RetType left_result = that.getLeft().visit(this);
1233 final RetType right_result = that.getRight().visit(this);
1234 return forEqualsExpressionOnly(that, left_result, right_result);
1235 }
1236
1237 public RetType forNotEqualExpression(NotEqualExpression that) {
1238 final RetType left_result = that.getLeft().visit(this);
1239 final RetType right_result = that.getRight().visit(this);
1240 return forNotEqualExpressionOnly(that, left_result, right_result);
1241 }
1242
1243 public RetType forLessThanExpression(LessThanExpression that) {
1244 final RetType left_result = that.getLeft().visit(this);
1245 final RetType right_result = that.getRight().visit(this);
1246 return forLessThanExpressionOnly(that, left_result, right_result);
1247 }
1248
1249 public RetType forLessThanOrEqualExpression(LessThanOrEqualExpression that) {
1250 final RetType left_result = that.getLeft().visit(this);
1251 final RetType right_result = that.getRight().visit(this);
1252 return forLessThanOrEqualExpressionOnly(that, left_result, right_result);
1253 }
1254
1255 public RetType forGreaterThanExpression(GreaterThanExpression that) {
1256 final RetType left_result = that.getLeft().visit(this);
1257 final RetType right_result = that.getRight().visit(this);
1258 return forGreaterThanExpressionOnly(that, left_result, right_result);
1259 }
1260
1261 public RetType forGreaterThanOrEqualExpression(GreaterThanOrEqualExpression that) {
1262 final RetType left_result = that.getLeft().visit(this);
1263 final RetType right_result = that.getRight().visit(this);
1264 return forGreaterThanOrEqualExpressionOnly(that, left_result, right_result);
1265 }
1266
1267 public RetType forLeftShiftExpression(LeftShiftExpression that) {
1268 final RetType left_result = that.getLeft().visit(this);
1269 final RetType right_result = that.getRight().visit(this);
1270 return forLeftShiftExpressionOnly(that, left_result, right_result);
1271 }
1272
1273 public RetType forRightSignedShiftExpression(RightSignedShiftExpression that) {
1274 final RetType left_result = that.getLeft().visit(this);
1275 final RetType right_result = that.getRight().visit(this);
1276 return forRightSignedShiftExpressionOnly(that, left_result, right_result);
1277 }
1278
1279 public RetType forRightUnsignedShiftExpression(RightUnsignedShiftExpression that) {
1280 final RetType left_result = that.getLeft().visit(this);
1281 final RetType right_result = that.getRight().visit(this);
1282 return forRightUnsignedShiftExpressionOnly(that, left_result, right_result);
1283 }
1284
1285 public RetType forPlusExpression(PlusExpression that) {
1286 final RetType left_result = that.getLeft().visit(this);
1287 final RetType right_result = that.getRight().visit(this);
1288 return forPlusExpressionOnly(that, left_result, right_result);
1289 }
1290
1291 public RetType forMinusExpression(MinusExpression that) {
1292 final RetType left_result = that.getLeft().visit(this);
1293 final RetType right_result = that.getRight().visit(this);
1294 return forMinusExpressionOnly(that, left_result, right_result);
1295 }
1296
1297 public RetType forMultiplyExpression(MultiplyExpression that) {
1298 final RetType left_result = that.getLeft().visit(this);
1299 final RetType right_result = that.getRight().visit(this);
1300 return forMultiplyExpressionOnly(that, left_result, right_result);
1301 }
1302
1303 public RetType forDivideExpression(DivideExpression that) {
1304 final RetType left_result = that.getLeft().visit(this);
1305 final RetType right_result = that.getRight().visit(this);
1306 return forDivideExpressionOnly(that, left_result, right_result);
1307 }
1308
1309 public RetType forModExpression(ModExpression that) {
1310 final RetType left_result = that.getLeft().visit(this);
1311 final RetType right_result = that.getRight().visit(this);
1312 return forModExpressionOnly(that, left_result, right_result);
1313 }
1314
1315 public RetType forNoOpExpression(NoOpExpression that) {
1316 final RetType left_result = that.getLeft().visit(this);
1317 final RetType right_result = that.getRight().visit(this);
1318 return forNoOpExpressionOnly(that, left_result, right_result);
1319 }
1320
1321 public RetType forPositivePrefixIncrementExpression(PositivePrefixIncrementExpression that) {
1322 final RetType value_result = that.getValue().visit(this);
1323 return forPositivePrefixIncrementExpressionOnly(that, value_result);
1324 }
1325
1326 public RetType forNegativePrefixIncrementExpression(NegativePrefixIncrementExpression that) {
1327 final RetType value_result = that.getValue().visit(this);
1328 return forNegativePrefixIncrementExpressionOnly(that, value_result);
1329 }
1330
1331 public RetType forPositivePostfixIncrementExpression(PositivePostfixIncrementExpression that) {
1332 final RetType value_result = that.getValue().visit(this);
1333 return forPositivePostfixIncrementExpressionOnly(that, value_result);
1334 }
1335
1336 public RetType forNegativePostfixIncrementExpression(NegativePostfixIncrementExpression that) {
1337 final RetType value_result = that.getValue().visit(this);
1338 return forNegativePostfixIncrementExpressionOnly(that, value_result);
1339 }
1340
1341 public RetType forPositiveExpression(PositiveExpression that) {
1342 final RetType value_result = that.getValue().visit(this);
1343 return forPositiveExpressionOnly(that, value_result);
1344 }
1345
1346 public RetType forNegativeExpression(NegativeExpression that) {
1347 final RetType value_result = that.getValue().visit(this);
1348 return forNegativeExpressionOnly(that, value_result);
1349 }
1350
1351 public RetType forBitwiseNotExpression(BitwiseNotExpression that) {
1352 final RetType value_result = that.getValue().visit(this);
1353 return forBitwiseNotExpressionOnly(that, value_result);
1354 }
1355
1356 public RetType forNotExpression(NotExpression that) {
1357 final RetType value_result = that.getValue().visit(this);
1358 return forNotExpressionOnly(that, value_result);
1359 }
1360
1361 public RetType forConditionalExpression(ConditionalExpression that) {
1362 final RetType condition_result = that.getCondition().visit(this);
1363 final RetType forTrue_result = that.getForTrue().visit(this);
1364 final RetType forFalse_result = that.getForFalse().visit(this);
1365 return forConditionalExpressionOnly(that, condition_result, forTrue_result, forFalse_result);
1366 }
1367
1368 public RetType forInstanceofExpression(InstanceofExpression that) {
1369 final RetType value_result = that.getValue().visit(this);
1370 final RetType type_result = that.getType().visit(this);
1371 return forInstanceofExpressionOnly(that, value_result, type_result);
1372 }
1373
1374 public RetType forCastExpression(CastExpression that) {
1375 final RetType type_result = that.getType().visit(this);
1376 final RetType value_result = that.getValue().visit(this);
1377 return forCastExpressionOnly(that, type_result, value_result);
1378 }
1379
1380 public RetType forIntegerLiteral(IntegerLiteral that) {
1381 return forIntegerLiteralOnly(that);
1382 }
1383
1384 public RetType forLongLiteral(LongLiteral that) {
1385 return forLongLiteralOnly(that);
1386 }
1387
1388 public RetType forDoubleLiteral(DoubleLiteral that) {
1389 return forDoubleLiteralOnly(that);
1390 }
1391
1392 public RetType forFloatLiteral(FloatLiteral that) {
1393 return forFloatLiteralOnly(that);
1394 }
1395
1396 public RetType forBooleanLiteral(BooleanLiteral that) {
1397 return forBooleanLiteralOnly(that);
1398 }
1399
1400 public RetType forCharLiteral(CharLiteral that) {
1401 return forCharLiteralOnly(that);
1402 }
1403
1404 public RetType forStringLiteral(StringLiteral that) {
1405 return forStringLiteralOnly(that);
1406 }
1407
1408 public RetType forNullLiteral(NullLiteral that) {
1409 return forNullLiteralOnly(that);
1410 }
1411
1412 public RetType forSimpleNamedClassInstantiation(SimpleNamedClassInstantiation that) {
1413 final RetType type_result = that.getType().visit(this);
1414 final RetType arguments_result = that.getArguments().visit(this);
1415 return forSimpleNamedClassInstantiationOnly(that, type_result, arguments_result);
1416 }
1417
1418 public RetType forComplexNamedClassInstantiation(ComplexNamedClassInstantiation that) {
1419 final RetType enclosing_result = that.getEnclosing().visit(this);
1420 final RetType type_result = that.getType().visit(this);
1421 final RetType arguments_result = that.getArguments().visit(this);
1422 return forComplexNamedClassInstantiationOnly(that, enclosing_result, type_result, arguments_result);
1423 }
1424
1425 public RetType forSimpleAnonymousClassInstantiation(SimpleAnonymousClassInstantiation that) {
1426 final RetType type_result = that.getType().visit(this);
1427 final RetType arguments_result = that.getArguments().visit(this);
1428 final RetType body_result = that.getBody().visit(this);
1429 return forSimpleAnonymousClassInstantiationOnly(that, type_result, arguments_result, body_result);
1430 }
1431
1432 public RetType forComplexAnonymousClassInstantiation(ComplexAnonymousClassInstantiation that) {
1433 final RetType enclosing_result = that.getEnclosing().visit(this);
1434 final RetType type_result = that.getType().visit(this);
1435 final RetType arguments_result = that.getArguments().visit(this);
1436 final RetType body_result = that.getBody().visit(this);
1437 return forComplexAnonymousClassInstantiationOnly(that, enclosing_result, type_result, arguments_result, body_result);
1438 }
1439
1440 public RetType forSimpleUninitializedArrayInstantiation(SimpleUninitializedArrayInstantiation that) {
1441 final RetType type_result = that.getType().visit(this);
1442 final RetType dimensionSizes_result = that.getDimensionSizes().visit(this);
1443 return forSimpleUninitializedArrayInstantiationOnly(that, type_result, dimensionSizes_result);
1444 }
1445
1446 public RetType forComplexUninitializedArrayInstantiation(ComplexUninitializedArrayInstantiation that) {
1447 final RetType enclosing_result = that.getEnclosing().visit(this);
1448 final RetType type_result = that.getType().visit(this);
1449 final RetType dimensionSizes_result = that.getDimensionSizes().visit(this);
1450 return forComplexUninitializedArrayInstantiationOnly(that, enclosing_result, type_result, dimensionSizes_result);
1451 }
1452
1453 public RetType forSimpleInitializedArrayInstantiation(SimpleInitializedArrayInstantiation that) {
1454 final RetType type_result = that.getType().visit(this);
1455 final RetType initializer_result = that.getInitializer().visit(this);
1456 return forSimpleInitializedArrayInstantiationOnly(that, type_result, initializer_result);
1457 }
1458
1459 public RetType forComplexInitializedArrayInstantiation(ComplexInitializedArrayInstantiation that) {
1460 final RetType enclosing_result = that.getEnclosing().visit(this);
1461 final RetType type_result = that.getType().visit(this);
1462 final RetType initializer_result = that.getInitializer().visit(this);
1463 return forComplexInitializedArrayInstantiationOnly(that, enclosing_result, type_result, initializer_result);
1464 }
1465
1466 public RetType forSimpleNameReference(SimpleNameReference that) {
1467 final RetType name_result = that.getName().visit(this);
1468 return forSimpleNameReferenceOnly(that, name_result);
1469 }
1470
1471 public RetType forComplexNameReference(ComplexNameReference that) {
1472 final RetType enclosing_result = that.getEnclosing().visit(this);
1473 final RetType name_result = that.getName().visit(this);
1474 return forComplexNameReferenceOnly(that, enclosing_result, name_result);
1475 }
1476
1477 public RetType forSimpleThisReference(SimpleThisReference that) {
1478 return forSimpleThisReferenceOnly(that);
1479 }
1480
1481 public RetType forComplexThisReference(ComplexThisReference that) {
1482 final RetType enclosing_result = that.getEnclosing().visit(this);
1483 return forComplexThisReferenceOnly(that, enclosing_result);
1484 }
1485
1486 public RetType forSimpleSuperReference(SimpleSuperReference that) {
1487 return forSimpleSuperReferenceOnly(that);
1488 }
1489
1490 public RetType forComplexSuperReference(ComplexSuperReference that) {
1491 final RetType enclosing_result = that.getEnclosing().visit(this);
1492 return forComplexSuperReferenceOnly(that, enclosing_result);
1493 }
1494
1495 public RetType forSimpleMethodInvocation(SimpleMethodInvocation that) {
1496 final RetType name_result = that.getName().visit(this);
1497 final RetType arguments_result = that.getArguments().visit(this);
1498 return forSimpleMethodInvocationOnly(that, name_result, arguments_result);
1499 }
1500
1501 public RetType forComplexMethodInvocation(ComplexMethodInvocation that) {
1502 final RetType enclosing_result = that.getEnclosing().visit(this);
1503 final RetType name_result = that.getName().visit(this);
1504 final RetType arguments_result = that.getArguments().visit(this);
1505 return forComplexMethodInvocationOnly(that, enclosing_result, name_result, arguments_result);
1506 }
1507
1508 public RetType forSimpleThisConstructorInvocation(SimpleThisConstructorInvocation that) {
1509 final RetType arguments_result = that.getArguments().visit(this);
1510 return forSimpleThisConstructorInvocationOnly(that, arguments_result);
1511 }
1512
1513 public RetType forComplexThisConstructorInvocation(ComplexThisConstructorInvocation that) {
1514 final RetType enclosing_result = that.getEnclosing().visit(this);
1515 final RetType arguments_result = that.getArguments().visit(this);
1516 return forComplexThisConstructorInvocationOnly(that, enclosing_result, arguments_result);
1517 }
1518
1519 public RetType forSimpleSuperConstructorInvocation(SimpleSuperConstructorInvocation that) {
1520 final RetType arguments_result = that.getArguments().visit(this);
1521 return forSimpleSuperConstructorInvocationOnly(that, arguments_result);
1522 }
1523
1524 public RetType forComplexSuperConstructorInvocation(ComplexSuperConstructorInvocation that) {
1525 final RetType enclosing_result = that.getEnclosing().visit(this);
1526 final RetType arguments_result = that.getArguments().visit(this);
1527 return forComplexSuperConstructorInvocationOnly(that, enclosing_result, arguments_result);
1528 }
1529
1530 public RetType forClassLiteral(ClassLiteral that) {
1531 final RetType type_result = that.getType().visit(this);
1532 return forClassLiteralOnly(that, type_result);
1533 }
1534
1535 public RetType forArrayAccess(ArrayAccess that) {
1536 final RetType array_result = that.getArray().visit(this);
1537 final RetType index_result = that.getIndex().visit(this);
1538 return forArrayAccessOnly(that, array_result, index_result);
1539 }
1540
1541 public RetType forParenthesized(Parenthesized that) {
1542 final RetType value_result = that.getValue().visit(this);
1543 return forParenthesizedOnly(that, value_result);
1544 }
1545
1546 public RetType forEmptyExpression(EmptyExpression that) {
1547 return forEmptyExpressionOnly(that);
1548 }
1549
1550 public RetType forBracedBody(BracedBody that) {
1551 final RetType[] statements_result = makeArrayOfRetType(that.getStatements().length);
1552 for (int i = 0; i < that.getStatements().length; i++) {
1553 statements_result[i] = that.getStatements()[i].visit(this);
1554 }
1555 return forBracedBodyOnly(that, statements_result);
1556 }
1557
1558 public RetType forUnbracedBody(UnbracedBody that) {
1559 final RetType[] statements_result = makeArrayOfRetType(that.getStatements().length);
1560 for (int i = 0; i < that.getStatements().length; i++) {
1561 statements_result[i] = that.getStatements()[i].visit(this);
1562 }
1563 return forUnbracedBodyOnly(that, statements_result);
1564 }
1565
1566 public RetType forParenthesizedExpressionList(ParenthesizedExpressionList that) {
1567 final RetType[] expressions_result = makeArrayOfRetType(that.getExpressions().length);
1568 for (int i = 0; i < that.getExpressions().length; i++) {
1569 expressions_result[i] = that.getExpressions()[i].visit(this);
1570 }
1571 return forParenthesizedExpressionListOnly(that, expressions_result);
1572 }
1573
1574 public RetType forUnparenthesizedExpressionList(UnparenthesizedExpressionList that) {
1575 final RetType[] expressions_result = makeArrayOfRetType(that.getExpressions().length);
1576 for (int i = 0; i < that.getExpressions().length; i++) {
1577 expressions_result[i] = that.getExpressions()[i].visit(this);
1578 }
1579 return forUnparenthesizedExpressionListOnly(that, expressions_result);
1580 }
1581
1582 public RetType forDimensionExpressionList(DimensionExpressionList that) {
1583 final RetType[] expressions_result = makeArrayOfRetType(that.getExpressions().length);
1584 for (int i = 0; i < that.getExpressions().length; i++) {
1585 expressions_result[i] = that.getExpressions()[i].visit(this);
1586 }
1587 return forDimensionExpressionListOnly(that, expressions_result);
1588 }
1589
1590 public RetType forEmptyForCondition(EmptyForCondition that) {
1591 return forEmptyForConditionOnly(that);
1592 }
1593
1594 }