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: 744   Methods: 182
NCLOC: 550   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
JExpressionIFAbstractVisitor.java - 17.6% 17.6% 17.6%
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    ** return the value of the defaultCase. These methods can be overriden
 6    ** in order to achieve different behavior for particular cases.
 7    **/
 8    public abstract class JExpressionIFAbstractVisitor<RetType> implements JExpressionIFVisitor<RetType> {
 9    /**
 10    * This method is run for all cases by default, unless they are overridden by subclasses.
 11    **/
 12    protected abstract RetType defaultCase(JExpressionIF that);
 13   
 14    /* Methods to visit an item. */
 15  75 public RetType forJExpression(JExpression that) {
 16  75 return defaultCase(that);
 17    }
 18   
 19  0 public RetType forSourceFile(SourceFile that) {
 20  0 return forJExpression(that);
 21    }
 22   
 23  0 public RetType forModifiersAndVisibility(ModifiersAndVisibility that) {
 24  0 return forJExpression(that);
 25    }
 26   
 27  0 public RetType forCompoundWord(CompoundWord that) {
 28  0 return forJExpression(that);
 29    }
 30   
 31  0 public RetType forWord(Word that) {
 32  0 return forJExpression(that);
 33    }
 34   
 35  13 public RetType forTypeDefBase(TypeDefBase that) {
 36  13 return forJExpression(that);
 37    }
 38   
 39  0 public RetType forClassDef(ClassDef that) {
 40  0 return forTypeDefBase(that);
 41    }
 42   
 43  0 public RetType forInnerClassDef(InnerClassDef that) {
 44  0 return forClassDef(that);
 45    }
 46   
 47  13 public RetType forInterfaceDef(InterfaceDef that) {
 48  13 return forTypeDefBase(that);
 49    }
 50   
 51  0 public RetType forInnerInterfaceDef(InnerInterfaceDef that) {
 52  0 return forInterfaceDef(that);
 53    }
 54   
 55  0 public RetType forConstructorDef(ConstructorDef that) {
 56  0 return forJExpression(that);
 57    }
 58   
 59  0 public RetType forInitializer(Initializer that) {
 60  0 return forJExpression(that);
 61    }
 62   
 63  0 public RetType forInstanceInitializer(InstanceInitializer that) {
 64  0 return forInitializer(that);
 65    }
 66   
 67  0 public RetType forStaticInitializer(StaticInitializer that) {
 68  0 return forInitializer(that);
 69    }
 70   
 71  0 public RetType forPackageStatement(PackageStatement that) {
 72  0 return forJExpression(that);
 73    }
 74   
 75  0 public RetType forImportStatement(ImportStatement that) {
 76  0 return forJExpression(that);
 77    }
 78   
 79  0 public RetType forClassImportStatement(ClassImportStatement that) {
 80  0 return forImportStatement(that);
 81    }
 82   
 83  0 public RetType forPackageImportStatement(PackageImportStatement that) {
 84  0 return forImportStatement(that);
 85    }
 86   
 87  0 public RetType forStatement(Statement that) {
 88  0 return forJExpression(that);
 89    }
 90   
 91  0 public RetType forLabeledStatement(LabeledStatement that) {
 92  0 return forStatement(that);
 93    }
 94   
 95  0 public RetType forBlock(Block that) {
 96  0 return forStatement(that);
 97    }
 98   
 99  0 public RetType forExpressionStatement(ExpressionStatement that) {
 100  0 return forStatement(that);
 101    }
 102   
 103  0 public RetType forSwitchStatement(SwitchStatement that) {
 104  0 return forStatement(that);
 105    }
 106   
 107  0 public RetType forIfThenStatement(IfThenStatement that) {
 108  0 return forStatement(that);
 109    }
 110   
 111  0 public RetType forIfThenElseStatement(IfThenElseStatement that) {
 112  0 return forIfThenStatement(that);
 113    }
 114   
 115  0 public RetType forWhileStatement(WhileStatement that) {
 116  0 return forStatement(that);
 117    }
 118   
 119  0 public RetType forDoStatement(DoStatement that) {
 120  0 return forStatement(that);
 121    }
 122   
 123  0 public RetType forForStatement(ForStatement that) {
 124  0 return forStatement(that);
 125    }
 126   
 127  0 public RetType forBreakStatement(BreakStatement that) {
 128  0 return forStatement(that);
 129    }
 130   
 131  0 public RetType forLabeledBreakStatement(LabeledBreakStatement that) {
 132  0 return forBreakStatement(that);
 133    }
 134   
 135  0 public RetType forUnlabeledBreakStatement(UnlabeledBreakStatement that) {
 136  0 return forBreakStatement(that);
 137    }
 138   
 139  0 public RetType forContinueStatement(ContinueStatement that) {
 140  0 return forStatement(that);
 141    }
 142   
 143  0 public RetType forLabeledContinueStatement(LabeledContinueStatement that) {
 144  0 return forContinueStatement(that);
 145    }
 146   
 147  0 public RetType forUnlabeledContinueStatement(UnlabeledContinueStatement that) {
 148  0 return forContinueStatement(that);
 149    }
 150   
 151  0 public RetType forReturnStatement(ReturnStatement that) {
 152  0 return forStatement(that);
 153    }
 154   
 155  0 public RetType forVoidReturnStatement(VoidReturnStatement that) {
 156  0 return forReturnStatement(that);
 157    }
 158   
 159  0 public RetType forValueReturnStatement(ValueReturnStatement that) {
 160  0 return forReturnStatement(that);
 161    }
 162   
 163  0 public RetType forThrowStatement(ThrowStatement that) {
 164  0 return forStatement(that);
 165    }
 166   
 167  0 public RetType forSynchronizedStatement(SynchronizedStatement that) {
 168  0 return forStatement(that);
 169    }
 170   
 171  0 public RetType forTryCatchStatement(TryCatchStatement that) {
 172  0 return forStatement(that);
 173    }
 174   
 175  0 public RetType forTryCatchFinallyStatement(TryCatchFinallyStatement that) {
 176  0 return forTryCatchStatement(that);
 177    }
 178   
 179  0 public RetType forNormalTryCatchStatement(NormalTryCatchStatement that) {
 180  0 return forTryCatchStatement(that);
 181    }
 182   
 183  0 public RetType forEmptyStatement(EmptyStatement that) {
 184  0 return forStatement(that);
 185    }
 186   
 187  0 public RetType forMethodDef(MethodDef that) {
 188  0 return forJExpression(that);
 189    }
 190   
 191  0 public RetType forConcreteMethodDef(ConcreteMethodDef that) {
 192  0 return forMethodDef(that);
 193    }
 194   
 195  0 public RetType forAbstractMethodDef(AbstractMethodDef that) {
 196  0 return forMethodDef(that);
 197    }
 198   
 199  0 public RetType forFormalParameter(FormalParameter that) {
 200  0 return forJExpression(that);
 201    }
 202   
 203  0 public RetType forVariableDeclaration(VariableDeclaration that) {
 204  0 return forJExpression(that);
 205    }
 206   
 207  0 public RetType forVariableDeclarator(VariableDeclarator that) {
 208  0 return forJExpression(that);
 209    }
 210   
 211  0 public RetType forUninitializedVariableDeclarator(UninitializedVariableDeclarator that) {
 212  0 return forVariableDeclarator(that);
 213    }
 214   
 215  0 public RetType forInitializedVariableDeclarator(InitializedVariableDeclarator that) {
 216  0 return forVariableDeclarator(that);
 217    }
 218   
 219  0 public RetType forTypeParameter(TypeParameter that) {
 220  0 return forJExpression(that);
 221    }
 222   
 223  0 public RetType forArrayInitializer(ArrayInitializer that) {
 224  0 return forJExpression(that);
 225    }
 226   
 227  0 public RetType forType(Type that) {
 228  0 return forJExpression(that);
 229    }
 230   
 231  0 public RetType forPrimitiveType(PrimitiveType that) {
 232  0 return forType(that);
 233    }
 234   
 235  0 public RetType forArrayType(ArrayType that) {
 236  0 return forType(that);
 237    }
 238   
 239  0 public RetType forReferenceType(ReferenceType that) {
 240  0 return forType(that);
 241    }
 242   
 243  0 public RetType forMemberType(MemberType that) {
 244  0 return forReferenceType(that);
 245    }
 246   
 247  0 public RetType forClassOrInterfaceType(ClassOrInterfaceType that) {
 248  0 return forReferenceType(that);
 249    }
 250   
 251  0 public RetType forTypeVariable(TypeVariable that) {
 252  0 return forReferenceType(that);
 253    }
 254   
 255  0 public RetType forVoidReturn(VoidReturn that) {
 256  0 return forJExpression(that);
 257    }
 258   
 259  0 public RetType forSwitchCase(SwitchCase that) {
 260  0 return forJExpression(that);
 261    }
 262   
 263  0 public RetType forLabeledCase(LabeledCase that) {
 264  0 return forSwitchCase(that);
 265    }
 266   
 267  0 public RetType forDefaultCase(DefaultCase that) {
 268  0 return forSwitchCase(that);
 269    }
 270   
 271  0 public RetType forCatchBlock(CatchBlock that) {
 272  0 return forJExpression(that);
 273    }
 274   
 275  62 public RetType forExpression(Expression that) {
 276  62 return forJExpression(that);
 277    }
 278   
 279  0 public RetType forAssignmentExpression(AssignmentExpression that) {
 280  0 return forExpression(that);
 281    }
 282   
 283  0 public RetType forSimpleAssignmentExpression(SimpleAssignmentExpression that) {
 284  0 return forAssignmentExpression(that);
 285    }
 286   
 287  2 public RetType forPlusAssignmentExpression(PlusAssignmentExpression that) {
 288  2 return forAssignmentExpression(that);
 289    }
 290   
 291  0 public RetType forNumericAssignmentExpression(NumericAssignmentExpression that) {
 292  0 return forAssignmentExpression(that);
 293    }
 294   
 295  0 public RetType forMinusAssignmentExpression(MinusAssignmentExpression that) {
 296  0 return forNumericAssignmentExpression(that);
 297    }
 298   
 299  0 public RetType forMultiplyAssignmentExpression(MultiplyAssignmentExpression that) {
 300  0 return forNumericAssignmentExpression(that);
 301    }
 302   
 303  0 public RetType forDivideAssignmentExpression(DivideAssignmentExpression that) {
 304  0 return forNumericAssignmentExpression(that);
 305    }
 306   
 307  0 public RetType forModAssignmentExpression(ModAssignmentExpression that) {
 308  0 return forNumericAssignmentExpression(that);
 309    }
 310   
 311  0 public RetType forShiftAssignmentExpression(ShiftAssignmentExpression that) {
 312  0 return forAssignmentExpression(that);
 313    }
 314   
 315  0 public RetType forLeftShiftAssignmentExpression(LeftShiftAssignmentExpression that) {
 316  0 return forShiftAssignmentExpression(that);
 317    }
 318   
 319  0 public RetType forRightSignedShiftAssignmentExpression(RightSignedShiftAssignmentExpression that) {
 320  0 return forShiftAssignmentExpression(that);
 321    }
 322   
 323  0 public RetType forRightUnsignedShiftAssignmentExpression(RightUnsignedShiftAssignmentExpression that) {
 324  0 return forShiftAssignmentExpression(that);
 325    }
 326   
 327  0 public RetType forBitwiseAssignmentExpression(BitwiseAssignmentExpression that) {
 328  0 return forAssignmentExpression(that);
 329    }
 330   
 331  0 public RetType forBitwiseAndAssignmentExpression(BitwiseAndAssignmentExpression that) {
 332  0 return forBitwiseAssignmentExpression(that);
 333    }
 334   
 335  0 public RetType forBitwiseOrAssignmentExpression(BitwiseOrAssignmentExpression that) {
 336  0 return forBitwiseAssignmentExpression(that);
 337    }
 338   
 339  0 public RetType forBitwiseXorAssignmentExpression(BitwiseXorAssignmentExpression that) {
 340  0 return forBitwiseAssignmentExpression(that);
 341    }
 342   
 343  37 public RetType forBinaryExpression(BinaryExpression that) {
 344  37 return forExpression(that);
 345    }
 346   
 347  0 public RetType forBooleanExpression(BooleanExpression that) {
 348  0 return forBinaryExpression(that);
 349    }
 350   
 351  0 public RetType forOrExpression(OrExpression that) {
 352  0 return forBooleanExpression(that);
 353    }
 354   
 355  0 public RetType forAndExpression(AndExpression that) {
 356  0 return forBooleanExpression(that);
 357    }
 358   
 359  0 public RetType forBitwiseBinaryExpression(BitwiseBinaryExpression that) {
 360  0 return forBinaryExpression(that);
 361    }
 362   
 363  0 public RetType forBitwiseOrExpression(BitwiseOrExpression that) {
 364  0 return forBitwiseBinaryExpression(that);
 365    }
 366   
 367  0 public RetType forBitwiseXorExpression(BitwiseXorExpression that) {
 368  0 return forBitwiseBinaryExpression(that);
 369    }
 370   
 371  0 public RetType forBitwiseAndExpression(BitwiseAndExpression that) {
 372  0 return forBitwiseBinaryExpression(that);
 373    }
 374   
 375  3 public RetType forEqualityExpression(EqualityExpression that) {
 376  3 return forBinaryExpression(that);
 377    }
 378   
 379  3 public RetType forEqualsExpression(EqualsExpression that) {
 380  3 return forEqualityExpression(that);
 381    }
 382   
 383  0 public RetType forNotEqualExpression(NotEqualExpression that) {
 384  0 return forEqualityExpression(that);
 385    }
 386   
 387  32 public RetType forComparisonExpression(ComparisonExpression that) {
 388  32 return forBinaryExpression(that);
 389    }
 390   
 391  30 public RetType forLessThanExpression(LessThanExpression that) {
 392  30 return forComparisonExpression(that);
 393    }
 394   
 395  1 public RetType forLessThanOrEqualExpression(LessThanOrEqualExpression that) {
 396  1 return forComparisonExpression(that);
 397    }
 398   
 399  1 public RetType forGreaterThanExpression(GreaterThanExpression that) {
 400  1 return forComparisonExpression(that);
 401    }
 402   
 403  0 public RetType forGreaterThanOrEqualExpression(GreaterThanOrEqualExpression that) {
 404  0 return forComparisonExpression(that);
 405    }
 406   
 407  0 public RetType forShiftBinaryExpression(ShiftBinaryExpression that) {
 408  0 return forBinaryExpression(that);
 409    }
 410   
 411  0 public RetType forLeftShiftExpression(LeftShiftExpression that) {
 412  0 return forShiftBinaryExpression(that);
 413    }
 414   
 415  0 public RetType forRightSignedShiftExpression(RightSignedShiftExpression that) {
 416  0 return forShiftBinaryExpression(that);
 417    }
 418   
 419  0 public RetType forRightUnsignedShiftExpression(RightUnsignedShiftExpression that) {
 420  0 return forShiftBinaryExpression(that);
 421    }
 422   
 423  2 public RetType forPlusExpression(PlusExpression that) {
 424  2 return forBinaryExpression(that);
 425    }
 426   
 427  0 public RetType forNumericBinaryExpression(NumericBinaryExpression that) {
 428  0 return forBinaryExpression(that);
 429    }
 430   
 431  0 public RetType forMinusExpression(MinusExpression that) {
 432  0 return forNumericBinaryExpression(that);
 433    }
 434   
 435  0 public RetType forMultiplyExpression(MultiplyExpression that) {
 436  0 return forNumericBinaryExpression(that);
 437    }
 438   
 439  0 public RetType forDivideExpression(DivideExpression that) {
 440  0 return forNumericBinaryExpression(that);
 441    }
 442   
 443  0 public RetType forModExpression(ModExpression that) {
 444  0 return forNumericBinaryExpression(that);
 445    }
 446   
 447  0 public RetType forNoOpExpression(NoOpExpression that) {
 448  0 return forBinaryExpression(that);
 449    }
 450   
 451  0 public RetType forUnaryExpression(UnaryExpression that) {
 452  0 return forExpression(that);
 453    }
 454   
 455  0 public RetType forIncrementExpression(IncrementExpression that) {
 456  0 return forUnaryExpression(that);
 457    }
 458   
 459  4 public RetType forPrefixIncrementExpression(PrefixIncrementExpression that) {
 460  4 return forIncrementExpression(that);
 461    }
 462   
 463  3 public RetType forPositivePrefixIncrementExpression(PositivePrefixIncrementExpression that) {
 464  3 return forPrefixIncrementExpression(that);
 465    }
 466   
 467  1 public RetType forNegativePrefixIncrementExpression(NegativePrefixIncrementExpression that) {
 468  1 return forPrefixIncrementExpression(that);
 469    }
 470   
 471  0 public RetType forPostfixIncrementExpression(PostfixIncrementExpression that) {
 472  0 return forIncrementExpression(that);
 473    }
 474   
 475  0 public RetType forPositivePostfixIncrementExpression(PositivePostfixIncrementExpression that) {
 476  0 return forPostfixIncrementExpression(that);
 477    }
 478   
 479  0 public RetType forNegativePostfixIncrementExpression(NegativePostfixIncrementExpression that) {
 480  0 return forPostfixIncrementExpression(that);
 481    }
 482   
 483  0 public RetType forNumericUnaryExpression(NumericUnaryExpression that) {
 484  0 return forUnaryExpression(that);
 485    }
 486   
 487  0 public RetType forPositiveExpression(PositiveExpression that) {
 488  0 return forNumericUnaryExpression(that);
 489    }
 490   
 491  0 public RetType forNegativeExpression(NegativeExpression that) {
 492  0 return forNumericUnaryExpression(that);
 493    }
 494   
 495  0 public RetType forBitwiseNotExpression(BitwiseNotExpression that) {
 496  0 return forUnaryExpression(that);
 497    }
 498   
 499  0 public RetType forNotExpression(NotExpression that) {
 500  0 return forUnaryExpression(that);
 501    }
 502   
 503  0 public RetType forConditionalExpression(ConditionalExpression that) {
 504  0 return forExpression(that);
 505    }
 506   
 507  0 public RetType forInstanceofExpression(InstanceofExpression that) {
 508  0 return forExpression(that);
 509    }
 510   
 511  0 public RetType forCastExpression(CastExpression that) {
 512  0 return forExpression(that);
 513    }
 514   
 515  25 public RetType forPrimary(Primary that) {
 516  25 return forExpression(that);
 517    }
 518   
 519  13 public RetType forLexicalLiteral(LexicalLiteral that) {
 520  13 return forPrimary(that);
 521    }
 522   
 523  3 public RetType forIntegerLiteral(IntegerLiteral that) {
 524  3 return forLexicalLiteral(that);
 525    }
 526   
 527  0 public RetType forLongLiteral(LongLiteral that) {
 528  0 return forLexicalLiteral(that);
 529    }
 530   
 531  1 public RetType forDoubleLiteral(DoubleLiteral that) {
 532  1 return forLexicalLiteral(that);
 533    }
 534   
 535  0 public RetType forFloatLiteral(FloatLiteral that) {
 536  0 return forLexicalLiteral(that);
 537    }
 538   
 539  7 public RetType forBooleanLiteral(BooleanLiteral that) {
 540  7 return forLexicalLiteral(that);
 541    }
 542   
 543  0 public RetType forCharLiteral(CharLiteral that) {
 544  0 return forLexicalLiteral(that);
 545    }
 546   
 547  0 public RetType forStringLiteral(StringLiteral that) {
 548  0 return forLexicalLiteral(that);
 549    }
 550   
 551  2 public RetType forNullLiteral(NullLiteral that) {
 552  2 return forLexicalLiteral(that);
 553    }
 554   
 555  2 public RetType forInstantiation(Instantiation that) {
 556  2 return forPrimary(that);
 557    }
 558   
 559  2 public RetType forClassInstantiation(ClassInstantiation that) {
 560  2 return forInstantiation(that);
 561    }
 562   
 563  1 public RetType forNamedClassInstantiation(NamedClassInstantiation that) {
 564  1 return forClassInstantiation(that);
 565    }
 566   
 567  1 public RetType forSimpleNamedClassInstantiation(SimpleNamedClassInstantiation that) {
 568  1 return forNamedClassInstantiation(that);
 569    }
 570   
 571  0 public RetType forComplexNamedClassInstantiation(ComplexNamedClassInstantiation that) {
 572  0 return forNamedClassInstantiation(that);
 573    }
 574   
 575  1 public RetType forAnonymousClassInstantiation(AnonymousClassInstantiation that) {
 576  1 return forClassInstantiation(that);
 577    }
 578   
 579  0 public RetType forSimpleAnonymousClassInstantiation(SimpleAnonymousClassInstantiation that) {
 580  0 return forAnonymousClassInstantiation(that);
 581    }
 582   
 583  1 public RetType forComplexAnonymousClassInstantiation(ComplexAnonymousClassInstantiation that) {
 584  1 return forAnonymousClassInstantiation(that);
 585    }
 586   
 587  0 public RetType forArrayInstantiation(ArrayInstantiation that) {
 588  0 return forInstantiation(that);
 589    }
 590   
 591  0 public RetType forUninitializedArrayInstantiation(UninitializedArrayInstantiation that) {
 592  0 return forArrayInstantiation(that);
 593    }
 594   
 595  0 public RetType forSimpleUninitializedArrayInstantiation(SimpleUninitializedArrayInstantiation that) {
 596  0 return forUninitializedArrayInstantiation(that);
 597    }
 598   
 599  0 public RetType forComplexUninitializedArrayInstantiation(ComplexUninitializedArrayInstantiation that) {
 600  0 return forUninitializedArrayInstantiation(that);
 601    }
 602   
 603  0 public RetType forInitializedArrayInstantiation(InitializedArrayInstantiation that) {
 604  0 return forArrayInstantiation(that);
 605    }
 606   
 607  0 public RetType forSimpleInitializedArrayInstantiation(SimpleInitializedArrayInstantiation that) {
 608  0 return forInitializedArrayInstantiation(that);
 609    }
 610   
 611  0 public RetType forComplexInitializedArrayInstantiation(ComplexInitializedArrayInstantiation that) {
 612  0 return forInitializedArrayInstantiation(that);
 613    }
 614   
 615  10 public RetType forVariableReference(VariableReference that) {
 616  10 return forPrimary(that);
 617    }
 618   
 619  10 public RetType forNameReference(NameReference that) {
 620  10 return forVariableReference(that);
 621    }
 622   
 623  95 public RetType forSimpleNameReference(SimpleNameReference that) {
 624  95 return forNameReference(that);
 625    }
 626   
 627  53 public RetType forComplexNameReference(ComplexNameReference that) {
 628  53 return forNameReference(that);
 629    }
 630   
 631  0 public RetType forThisReference(ThisReference that) {
 632  0 return forVariableReference(that);
 633    }
 634   
 635  0 public RetType forSimpleThisReference(SimpleThisReference that) {
 636  0 return forThisReference(that);
 637    }
 638   
 639  0 public RetType forComplexThisReference(ComplexThisReference that) {
 640  0 return forThisReference(that);
 641    }
 642   
 643  0 public RetType forSuperReference(SuperReference that) {
 644  0 return forVariableReference(that);
 645    }
 646   
 647  0 public RetType forSimpleSuperReference(SimpleSuperReference that) {
 648  0 return forSuperReference(that);
 649    }
 650   
 651  0 public RetType forComplexSuperReference(ComplexSuperReference that) {
 652  0 return forSuperReference(that);
 653    }
 654   
 655  0 public RetType forFunctionInvocation(FunctionInvocation that) {
 656  0 return forPrimary(that);
 657    }
 658   
 659  0 public RetType forMethodInvocation(MethodInvocation that) {
 660  0 return forFunctionInvocation(that);
 661    }
 662   
 663  0 public RetType forSimpleMethodInvocation(SimpleMethodInvocation that) {
 664  0 return forMethodInvocation(that);
 665    }
 666   
 667  0 public RetType forComplexMethodInvocation(ComplexMethodInvocation that) {
 668  0 return forMethodInvocation(that);
 669    }
 670   
 671  0 public RetType forThisConstructorInvocation(ThisConstructorInvocation that) {
 672  0 return forFunctionInvocation(that);
 673    }
 674   
 675  0 public RetType forSimpleThisConstructorInvocation(SimpleThisConstructorInvocation that) {
 676  0 return forThisConstructorInvocation(that);
 677    }
 678   
 679  0 public RetType forComplexThisConstructorInvocation(ComplexThisConstructorInvocation that) {
 680  0 return forThisConstructorInvocation(that);
 681    }
 682   
 683  0 public RetType forSuperConstructorInvocation(SuperConstructorInvocation that) {
 684  0 return forFunctionInvocation(that);
 685    }
 686   
 687  0 public RetType forSimpleSuperConstructorInvocation(SimpleSuperConstructorInvocation that) {
 688  0 return forSuperConstructorInvocation(that);
 689    }
 690   
 691  0 public RetType forComplexSuperConstructorInvocation(ComplexSuperConstructorInvocation that) {
 692  0 return forSuperConstructorInvocation(that);
 693    }
 694   
 695  0 public RetType forClassLiteral(ClassLiteral that) {
 696  0 return forPrimary(that);
 697    }
 698   
 699  0 public RetType forArrayAccess(ArrayAccess that) {
 700  0 return forPrimary(that);
 701    }
 702   
 703  0 public RetType forParenthesized(Parenthesized that) {
 704  0 return forPrimary(that);
 705    }
 706   
 707  0 public RetType forEmptyExpression(EmptyExpression that) {
 708  0 return forPrimary(that);
 709    }
 710   
 711  0 public RetType forBody(Body that) {
 712  0 return forJExpression(that);
 713    }
 714   
 715  0 public RetType forBracedBody(BracedBody that) {
 716  0 return forBody(that);
 717    }
 718   
 719  0 public RetType forUnbracedBody(UnbracedBody that) {
 720  0 return forBody(that);
 721    }
 722   
 723  0 public RetType forExpressionList(ExpressionList that) {
 724  0 return forJExpression(that);
 725    }
 726   
 727  0 public RetType forParenthesizedExpressionList(ParenthesizedExpressionList that) {
 728  0 return forExpressionList(that);
 729    }
 730   
 731  0 public RetType forUnparenthesizedExpressionList(UnparenthesizedExpressionList that) {
 732  0 return forExpressionList(that);
 733    }
 734   
 735  0 public RetType forDimensionExpressionList(DimensionExpressionList that) {
 736  0 return forExpressionList(that);
 737    }
 738   
 739  0 public RetType forEmptyForCondition(EmptyForCondition that) {
 740  0 return forJExpression(that);
 741    }
 742   
 743   
 744    }
 
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.