com.sun.source.tree

## Interface TreeVisitor<R,P>

Type Parameters:
  `R` - the return type of this visitor's methods. Use `Void` for visitors that do not need to return results.
  `P` - the type of the additional parameter to this visitor's methods. Use `Void` for visitors that do not need an additional parameter.

All Known Implementing Classes:
  SimpleTreeVisitor, TreePathScanner, TreeScanner

    @Exported
    public interface TreeVisitor<R,P>

A visitor of trees, in the style of the visitor design pattern. Classes implementing this interface are used to operate on a tree when the kind of tree is unknown at compile time. When a visitor is passed to an tree's `accept` method, the `visitXYZ` method most applicable to that tree is invoked.

Classes implementing this interface may or may not throw a `NullPointerException` if the additional parameter `p` is `null`; see documentation of the implementing class for details.

WARNING: It is possible that methods will be added to this interface to accommodate new, currently unknown, language structures added to future versions of the Java™ programming language. Therefore, visitor classes directly implementing this interface may be source incompatible with future versions of the platform.

Since:
  1.6

### Method Summary

All Methods Instance Methods Abstract Methods
`R` `visitAnnotatedType(AnnotatedTypeTree node, P p)`
`R` `visitAnnotation(AnnotationTree node, P p)`
`R` `visitArrayAccess(ArrayAccessTree node, P p)`
`R` `visitArrayType(ArrayTypeTree node, P p)`
`R` `visitAssert(AssertTree node, P p)`
`R` `visitAssignment(AssignmentTree node, P p)`
`R` `visitBinary(BinaryTree node, P p)`
`R` `visitBlock(BlockTree node, P p)`
`R` `visitBreak(BreakTree node, P p)`
`R` `visitCase(CaseTree node, P p)`
`R` `visitCatch(CatchTree node, P p)`
`R` `visitClass(ClassTree node, P p)`
`R` `visitCompilationUnit(CompilationUnitTree node, P p)`
`R` `visitCompoundAssignment(CompoundAssignmentTree node, P p)`
`R` `visitConditionalExpression(ConditionalExpressionTree node, P p)`
`R` `visitContinue(ContinueTree node, P p)`
`R` `visitDoWhileLoop(DoWhileLoopTree node, P p)`
`R` `visitEmptyStatement(EmptyStatementTree node, P p)`
`R` `visitEnhancedForLoop(EnhancedForLoopTree node, P p)`
`R` `visitErroneous(ErroneousTree node, P p)`
`R` `visitExpressionStatement(ExpressionStatementTree node, P p)`
`R` `visitForLoop(ForLoopTree node, P p)`
`R` `visitIdentifier(IdentifierTree node, P p)`
`R` `visitIf(IfTree node, P p)`
`R` `visitImport(ImportTree node, P p)`
`R` `visitInstanceOf(InstanceOfTree node, P p)`
`R` `visitIntersectionType(IntersectionTypeTree node, P p)`
`R` `visitLabeledStatement(LabeledStatementTree node, P p)`
`R` `visitLambdaExpression(LambdaExpressionTree node, P p)`
`R` `visitLiteral(LiteralTree node, P p)`
`R` `visitMemberReference(MemberReferenceTree node, P p)`
`R` `visitMemberSelect(MemberSelectTree node, P p)`
`R` `visitMethod(MethodTree node, P p)`
`R` `visitMethodInvocation(MethodInvocationTree node, P p)`
`R` `visitModifiers(ModifiersTree node, P p)`
`R` `visitNewArray(NewArrayTree node, P p)`
`R` `visitNewClass(NewClassTree node, P p)`
`R` `visitOther(Tree node, P p)`
`R` `visitParameterizedType(ParameterizedTypeTree node, P p)`
`R` `visitParenthesized(ParenthesizedTree node, P p)`
`R` `visitPrimitiveType(PrimitiveTypeTree node, P p)`
`R` `visitReturn(ReturnTree node, P p)`
`R` `visitSwitch(SwitchTree node, P p)`
`R` `visitSynchronized(SynchronizedTree node, P p)`
`R` `visitThrow(ThrowTree node, P p)`
`R` `visitTry(TryTree node, P p)`
`R` `visitTypeCast(TypeCastTree node, P p)`
`R` `visitTypeParameter(TypeParameterTree node, P p)`
`R` `visitUnary(UnaryTree node, P p)`
`R` `visitUnionType(UnionTypeTree node, P p)`
`R` `visitVariable(VariableTree node, P p)`
`R` `visitWhileLoop(WhileLoopTree node, P p)`
`R` `visitWildcard(WildcardTree node, P p)`

### Method Detail

#### visitAnnotatedType

    R visitAnnotatedType(AnnotatedTypeTree node,
                         P p)

#### visitAnnotation

    R visitAnnotation(AnnotationTree node,
                      P p)

#### visitMethodInvocation

    R visitMethodInvocation(MethodInvocationTree node,
                            P p)

#### visitAssert

    R visitAssert(AssertTree node,
                  P p)

#### visitAssignment

    R visitAssignment(AssignmentTree node,
                      P p)

#### visitCompoundAssignment

    R visitCompoundAssignment(CompoundAssignmentTree node,
                              P p)

#### visitBinary

    R visitBinary(BinaryTree node,
                  P p)

#### visitBlock

    R visitBlock(BlockTree node,
                 P p)

#### visitBreak

    R visitBreak(BreakTree node,
                 P p)

#### visitCase

    R visitCase(CaseTree node,
                P p)

#### visitCatch

    R visitCatch(CatchTree node,
                 P p)

#### visitClass

    R visitClass(ClassTree node,
                 P p)

#### visitConditionalExpression

    R visitConditionalExpression(ConditionalExpressionTree node,
                                 P p)

#### visitContinue

    R visitContinue(ContinueTree node,
                    P p)

#### visitDoWhileLoop

    R visitDoWhileLoop(DoWhileLoopTree node,
                       P p)

#### visitErroneous

    R visitErroneous(ErroneousTree node,
                     P p)

#### visitExpressionStatement

    R visitExpressionStatement(ExpressionStatementTree node,
                               P p)

#### visitEnhancedForLoop

    R visitEnhancedForLoop(EnhancedForLoopTree node,
                           P p)

#### visitForLoop

    R visitForLoop(ForLoopTree node,
                   P p)

#### visitIdentifier

    R visitIdentifier(IdentifierTree node,
                      P p)

#### visitIf

    R visitIf(IfTree node,
              P p)

#### visitImport

    R visitImport(ImportTree node,
                  P p)

#### visitArrayAccess

    R visitArrayAccess(ArrayAccessTree node,
                       P p)

#### visitLabeledStatement

    R visitLabeledStatement(LabeledStatementTree node,
                            P p)

#### visitLiteral

    R visitLiteral(LiteralTree node,
                   P p)

#### visitMethod

    R visitMethod(MethodTree node,
                  P p)

#### visitModifiers

    R visitModifiers(ModifiersTree node,
                     P p)

#### visitNewArray

    R visitNewArray(NewArrayTree node,
                    P p)

#### visitNewClass

    R visitNewClass(NewClassTree node,
                    P p)

#### visitLambdaExpression

    R visitLambdaExpression(LambdaExpressionTree node,
                            P p)

#### visitParenthesized

    R visitParenthesized(ParenthesizedTree node,
                         P p)

#### visitReturn

    R visitReturn(ReturnTree node,
                  P p)

#### visitMemberSelect

    R visitMemberSelect(MemberSelectTree node,
                        P p)

#### visitMemberReference

    R visitMemberReference(MemberReferenceTree node,
                           P p)

#### visitEmptyStatement

    R visitEmptyStatement(EmptyStatementTree node,
                          P p)

#### visitSwitch

    R visitSwitch(SwitchTree node,
                  P p)

#### visitSynchronized

    R visitSynchronized(SynchronizedTree node,
                        P p)

#### visitThrow

    R visitThrow(ThrowTree node,
                 P p)

#### visitCompilationUnit

    R visitCompilationUnit(CompilationUnitTree node,
                           P p)

#### visitTry

    R visitTry(TryTree node,
               P p)

#### visitParameterizedType

    R visitParameterizedType(ParameterizedTypeTree node,
                             P p)

#### visitUnionType

    R visitUnionType(UnionTypeTree node,
                     P p)

#### visitIntersectionType

    R visitIntersectionType(IntersectionTypeTree node,
                            P p)

#### visitArrayType

    R visitArrayType(ArrayTypeTree node,
                     P p)

#### visitTypeCast

    R visitTypeCast(TypeCastTree node,
                    P p)

#### visitPrimitiveType

    R visitPrimitiveType(PrimitiveTypeTree node,
                         P p)

#### visitTypeParameter

    R visitTypeParameter(TypeParameterTree node,
                         P p)

#### visitInstanceOf

    R visitInstanceOf(InstanceOfTree node,
                      P p)

#### visitUnary

    R visitUnary(UnaryTree node,
                 P p)

#### visitVariable

    R visitVariable(VariableTree node,
                    P p)

#### visitWhileLoop

    R visitWhileLoop(WhileLoopTree node,
                     P p)

#### visitWildcard

    R visitWildcard(WildcardTree node,
                    P p)

#### visitOther

    R visitOther(Tree node,
                 P p)