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