Module jdk.compiler
Package com.sun.source.util

## Class SimpleTreeVisitor<R,​P>

- java.lang.Object
- - com.sun.source.util.SimpleTreeVisitor<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 Implemented Interfaces:
  `TreeVisitor<R,​P>`

    public class SimpleTreeVisitor<R,​P>
    extends Object
    implements TreeVisitor<R,​P>

A simple visitor for tree nodes.

Since:
  1.6

### Field Summary

Fields
`protected R` `DEFAULT_VALUE` The default value, returned by the `default action`.

### Constructor Summary

Constructors
`protected` `SimpleTreeVisitor()` Creates a visitor, with a DEFAULT_VALUE of `null`.
`protected` `SimpleTreeVisitor​(R defaultValue)` Creates a visitor, with a specified DEFAULT_VALUE.

### Method Summary

All Methods Instance Methods Concrete Methods
`protected R` `defaultAction​(Tree node, P p)` The default action, used by all visit methods that are not overridden.
`R` `visit​(Tree node, P p)` Invokes the appropriate visit method specific to the type of the node.
`R` `visit​(Iterable<? extends Tree> nodes, P p)` Invokes the appropriate visit method on each of a sequence of nodes.
`R` `visitAnnotatedType​(AnnotatedTypeTree node, P p)` Visits an AnnotatedTypeTree node.
`R` `visitAnnotation​(AnnotationTree node, P p)` Visits an AnnotatedTree node.
`R` `visitArrayAccess​(ArrayAccessTree node, P p)` Visits an ArrayAccessTree node.
`R` `visitArrayType​(ArrayTypeTree node, P p)` Visits an ArrayTypeTree node.
`R` `visitAssert​(AssertTree node, P p)` Visits an AssertTree node.
`R` `visitAssignment​(AssignmentTree node, P p)` Visits an AssignmentTree node.
`R` `visitBinary​(BinaryTree node, P p)` Visits a BinaryTree node.
`R` `visitBlock​(BlockTree node, P p)` Visits a BlockTree node.
`R` `visitBreak​(BreakTree node, P p)` Visits a BreakTree node.
`R` `visitCase​(CaseTree node, P p)` Visits a CaseTree node.
`R` `visitCatch​(CatchTree node, P p)` Visits a CatchTree node.
`R` `visitClass​(ClassTree node, P p)` Visits a ClassTree node.
`R` `visitCompilationUnit​(CompilationUnitTree node, P p)` Visits a CompilationUnitTree node.
`R` `visitCompoundAssignment​(CompoundAssignmentTree node, P p)` Visits a CompoundAssignmentTree node.
`R` `visitConditionalExpression​(ConditionalExpressionTree node, P p)` Visits a ConditionalExpressionTree node.
`R` `visitContinue​(ContinueTree node, P p)` Visits a ContinueTree node.
`R` `visitDoWhileLoop​(DoWhileLoopTree node, P p)` Visits a DoWhileTree node.
`R` `visitEmptyStatement​(EmptyStatementTree node, P p)` Visits an EmptyStatementTree node.
`R` `visitEnhancedForLoop​(EnhancedForLoopTree node, P p)` Visits an EnhancedForLoopTree node.
`R` `visitExpressionStatement​(ExpressionStatementTree node, P p)` Visits an ExpressionStatementTree node.
`R` `visitForLoop​(ForLoopTree node, P p)` Visits a ForLoopTree node.
`R` `visitIdentifier​(IdentifierTree node, P p)` Visits an IdentifierTree node.
`R` `visitIf​(IfTree node, P p)` Visits an IfTree node.
`R` `visitImport​(ImportTree node, P p)` Visits an ImportTree node.
`R` `visitInstanceOf​(InstanceOfTree node, P p)` Visits an InstanceOfTree node.
`R` `visitIntersectionType​(IntersectionTypeTree node, P p)` Visits an IntersectionTypeTree node.
`R` `visitLabeledStatement​(LabeledStatementTree node, P p)` Visits a LabeledStatementTree node.
`R` `visitLambdaExpression​(LambdaExpressionTree node, P p)` Visits a LambdaExpressionTree node.
`R` `visitLiteral​(LiteralTree node, P p)` Visits a LiteralTree node.
`R` `visitMemberReference​(MemberReferenceTree node, P p)` Visits a MemberReferenceTree node.
`R` `visitMemberSelect​(MemberSelectTree node, P p)` Visits a MemberSelectTree node.
`R` `visitMethod​(MethodTree node, P p)` Visits a MethodTree node.
`R` `visitMethodInvocation​(MethodInvocationTree node, P p)` Visits a MethodInvocationTree node.
`R` `visitModifiers​(ModifiersTree node, P p)` Visits a ModifiersTree node.
`R` `visitNewArray​(NewArrayTree node, P p)` Visits a NewArrayTree node.
`R` `visitNewClass​(NewClassTree node, P p)` Visits a NewClassTree node.
`R` `visitOther​(Tree node, P p)` Visits an unknown type of Tree node.
`R` `visitPackage​(PackageTree node, P p)` Visits a PackageTree node.
`R` `visitParameterizedType​(ParameterizedTypeTree node, P p)` Visits a ParameterizedTypeTree node.
`R` `visitParenthesized​(ParenthesizedTree node, P p)` Visits a ParenthesizedTree node.
`R` `visitPrimitiveType​(PrimitiveTypeTree node, P p)` Visits a PrimitiveTypeTree node.
`R` `visitReturn​(ReturnTree node, P p)` Visits a ReturnTree node.
`R` `visitSwitch​(SwitchTree node, P p)` Visits a SwitchTree node.
`R` `visitSynchronized​(SynchronizedTree node, P p)` Visits a SynchronizedTree node.
`R` `visitThrow​(ThrowTree node, P p)` Visits a ThrowTree node.
`R` `visitTry​(TryTree node, P p)` Visits a TryTree node.
`R` `visitTypeCast​(TypeCastTree node, P p)` Visits a TypeCastTree node.
`R` `visitTypeParameter​(TypeParameterTree node, P p)` Visits a TypeParameterTree node.
`R` `visitUnary​(UnaryTree node, P p)` Visits a UnaryTree node.
`R` `visitUnionType​(UnionTypeTree node, P p)` Visits a UnionTypeTree node.
`R` `visitVariable​(VariableTree node, P p)` Visits a VariableTree node.
`R` `visitWhileLoop​(WhileLoopTree node, P p)` Visits a WhileLoopTree node.
`R` `visitWildcard​(WildcardTree node, P p)` Visits a WildcardTypeTree node.

### Methods declared in class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Methods declared in interface com.sun.source.tree.TreeVisitor

`visitErroneous, visitExports, visitModule, visitOpens, visitProvides, visitRequires, visitUses`

### Field Detail

#### DEFAULT_VALUE

    protected final R DEFAULT_VALUE

The default value, returned by the `default action`.

### Constructor Detail

#### SimpleTreeVisitor

    protected SimpleTreeVisitor()

Creates a visitor, with a DEFAULT_VALUE of `null`.

#### SimpleTreeVisitor

    protected SimpleTreeVisitor​(R defaultValue)

Creates a visitor, with a specified DEFAULT_VALUE.

Parameters:
  `defaultValue` - the default value to be returned by the default action.

### Method Detail

#### defaultAction

    protected R defaultAction​(Tree node,
                              P p)

The default action, used by all visit methods that are not overridden.

Parameters:
  `node` - the node being visited
  `p` - the parameter value passed to the visit method
Returns:
  the result value to be returned from the visit method

#### visit

    public final R visit​(Tree node,
                         P p)

Invokes the appropriate visit method specific to the type of the node.

Parameters:
  `node` - the node on which to dispatch
  `p` - a parameter to be passed to the appropriate visit method
Returns:
  the value returns from the appropriate visit method

#### visit

    public final R visit​(Iterable<? extends Tree> nodes,
                         P p)

Invokes the appropriate visit method on each of a sequence of nodes.

Parameters:
  `nodes` - the nodes on which to dispatch
  `p` - a parameter value to be passed to each appropriate visit method
Returns:
  the value return from the last of the visit methods, or null if none were called.

#### visitCompilationUnit

    public R visitCompilationUnit​(CompilationUnitTree node,
                                  P p)

Visits a CompilationUnitTree node. This implementation calls `defaultAction`.

Specified by:
  `visitCompilationUnit` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitPackage

    public R visitPackage​(PackageTree node,
                          P p)

Visits a PackageTree node. This implementation calls `defaultAction`.

Specified by:
  `visitPackage` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitImport

    public R visitImport​(ImportTree node,
                         P p)

Visits an ImportTree node. This implementation calls `defaultAction`.

Specified by:
  `visitImport` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitClass

    public R visitClass​(ClassTree node,
                        P p)

Visits a ClassTree node. This implementation calls `defaultAction`.

Specified by:
  `visitClass` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitMethod

    public R visitMethod​(MethodTree node,
                         P p)

Visits a MethodTree node. This implementation calls `defaultAction`.

Specified by:
  `visitMethod` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitVariable

    public R visitVariable​(VariableTree node,
                           P p)

Visits a VariableTree node. This implementation calls `defaultAction`.

Specified by:
  `visitVariable` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitEmptyStatement

    public R visitEmptyStatement​(EmptyStatementTree node,
                                 P p)

Visits an EmptyStatementTree node. This implementation calls `defaultAction`.

Specified by:
  `visitEmptyStatement` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitBlock

    public R visitBlock​(BlockTree node,
                        P p)

Visits a BlockTree node. This implementation calls `defaultAction`.

Specified by:
  `visitBlock` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitDoWhileLoop

    public R visitDoWhileLoop​(DoWhileLoopTree node,
                              P p)

Visits a DoWhileTree node. This implementation calls `defaultAction`.

Specified by:
  `visitDoWhileLoop` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitWhileLoop

    public R visitWhileLoop​(WhileLoopTree node,
                            P p)

Visits a WhileLoopTree node. This implementation calls `defaultAction`.

Specified by:
  `visitWhileLoop` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitForLoop

    public R visitForLoop​(ForLoopTree node,
                          P p)

Visits a ForLoopTree node. This implementation calls `defaultAction`.

Specified by:
  `visitForLoop` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitEnhancedForLoop

    public R visitEnhancedForLoop​(EnhancedForLoopTree node,
                                  P p)

Visits an EnhancedForLoopTree node. This implementation calls `defaultAction`.

Specified by:
  `visitEnhancedForLoop` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitLabeledStatement

    public R visitLabeledStatement​(LabeledStatementTree node,
                                   P p)

Visits a LabeledStatementTree node. This implementation calls `defaultAction`.

Specified by:
  `visitLabeledStatement` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitSwitch

    public R visitSwitch​(SwitchTree node,
                         P p)

Visits a SwitchTree node. This implementation calls `defaultAction`.

Specified by:
  `visitSwitch` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitCase

    public R visitCase​(CaseTree node,
                       P p)

Visits a CaseTree node. This implementation calls `defaultAction`.

Specified by:
  `visitCase` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitSynchronized

    public R visitSynchronized​(SynchronizedTree node,
                               P p)

Visits a SynchronizedTree node. This implementation calls `defaultAction`.

Specified by:
  `visitSynchronized` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitTry

    public R visitTry​(TryTree node,
                      P p)

Visits a TryTree node. This implementation calls `defaultAction`.

Specified by:
  `visitTry` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitCatch

    public R visitCatch​(CatchTree node,
                        P p)

Visits a CatchTree node. This implementation calls `defaultAction`.

Specified by:
  `visitCatch` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitConditionalExpression

    public R visitConditionalExpression​(ConditionalExpressionTree node,
                                        P p)

Visits a ConditionalExpressionTree node. This implementation calls `defaultAction`.

Specified by:
  `visitConditionalExpression` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitIf

    public R visitIf​(IfTree node,
                     P p)

Visits an IfTree node. This implementation calls `defaultAction`.

Specified by:
  `visitIf` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitExpressionStatement

    public R visitExpressionStatement​(ExpressionStatementTree node,
                                      P p)

Visits an ExpressionStatementTree node. This implementation calls `defaultAction`.

Specified by:
  `visitExpressionStatement` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitBreak

    public R visitBreak​(BreakTree node,
                        P p)

Visits a BreakTree node. This implementation calls `defaultAction`.

Specified by:
  `visitBreak` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitContinue

    public R visitContinue​(ContinueTree node,
                           P p)

Visits a ContinueTree node. This implementation calls `defaultAction`.

Specified by:
  `visitContinue` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitReturn

    public R visitReturn​(ReturnTree node,
                         P p)

Visits a ReturnTree node. This implementation calls `defaultAction`.

Specified by:
  `visitReturn` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitThrow

    public R visitThrow​(ThrowTree node,
                        P p)

Visits a ThrowTree node. This implementation calls `defaultAction`.

Specified by:
  `visitThrow` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitAssert

    public R visitAssert​(AssertTree node,
                         P p)

Visits an AssertTree node. This implementation calls `defaultAction`.

Specified by:
  `visitAssert` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitMethodInvocation

    public R visitMethodInvocation​(MethodInvocationTree node,
                                   P p)

Visits a MethodInvocationTree node. This implementation calls `defaultAction`.

Specified by:
  `visitMethodInvocation` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitNewClass

    public R visitNewClass​(NewClassTree node,
                           P p)

Visits a NewClassTree node. This implementation calls `defaultAction`.

Specified by:
  `visitNewClass` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitNewArray

    public R visitNewArray​(NewArrayTree node,
                           P p)

Visits a NewArrayTree node. This implementation calls `defaultAction`.

Specified by:
  `visitNewArray` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitLambdaExpression

    public R visitLambdaExpression​(LambdaExpressionTree node,
                                   P p)

Visits a LambdaExpressionTree node. This implementation calls `defaultAction`.

Specified by:
  `visitLambdaExpression` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitParenthesized

    public R visitParenthesized​(ParenthesizedTree node,
                                P p)

Visits a ParenthesizedTree node. This implementation calls `defaultAction`.

Specified by:
  `visitParenthesized` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitAssignment

    public R visitAssignment​(AssignmentTree node,
                             P p)

Visits an AssignmentTree node. This implementation calls `defaultAction`.

Specified by:
  `visitAssignment` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitCompoundAssignment

    public R visitCompoundAssignment​(CompoundAssignmentTree node,
                                     P p)

Visits a CompoundAssignmentTree node. This implementation calls `defaultAction`.

Specified by:
  `visitCompoundAssignment` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitUnary

    public R visitUnary​(UnaryTree node,
                        P p)

Visits a UnaryTree node. This implementation calls `defaultAction`.

Specified by:
  `visitUnary` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitBinary

    public R visitBinary​(BinaryTree node,
                         P p)

Visits a BinaryTree node. This implementation calls `defaultAction`.

Specified by:
  `visitBinary` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitTypeCast

    public R visitTypeCast​(TypeCastTree node,
                           P p)

Visits a TypeCastTree node. This implementation calls `defaultAction`.

Specified by:
  `visitTypeCast` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitInstanceOf

    public R visitInstanceOf​(InstanceOfTree node,
                             P p)

Visits an InstanceOfTree node. This implementation calls `defaultAction`.

Specified by:
  `visitInstanceOf` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitArrayAccess

    public R visitArrayAccess​(ArrayAccessTree node,
                              P p)

Visits an ArrayAccessTree node. This implementation calls `defaultAction`.

Specified by:
  `visitArrayAccess` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitMemberSelect

    public R visitMemberSelect​(MemberSelectTree node,
                               P p)

Visits a MemberSelectTree node. This implementation calls `defaultAction`.

Specified by:
  `visitMemberSelect` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitMemberReference

    public R visitMemberReference​(MemberReferenceTree node,
                                  P p)

Visits a MemberReferenceTree node. This implementation calls `defaultAction`.

Specified by:
  `visitMemberReference` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitIdentifier

    public R visitIdentifier​(IdentifierTree node,
                             P p)

Visits an IdentifierTree node. This implementation calls `defaultAction`.

Specified by:
  `visitIdentifier` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitLiteral

    public R visitLiteral​(LiteralTree node,
                          P p)

Visits a LiteralTree node. This implementation calls `defaultAction`.

Specified by:
  `visitLiteral` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitPrimitiveType

    public R visitPrimitiveType​(PrimitiveTypeTree node,
                                P p)

Visits a PrimitiveTypeTree node. This implementation calls `defaultAction`.

Specified by:
  `visitPrimitiveType` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitArrayType

    public R visitArrayType​(ArrayTypeTree node,
                            P p)

Visits an ArrayTypeTree node. This implementation calls `defaultAction`.

Specified by:
  `visitArrayType` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitParameterizedType

    public R visitParameterizedType​(ParameterizedTypeTree node,
                                    P p)

Visits a ParameterizedTypeTree node. This implementation calls `defaultAction`.

Specified by:
  `visitParameterizedType` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitUnionType

    public R visitUnionType​(UnionTypeTree node,
                            P p)

Visits a UnionTypeTree node. This implementation calls `defaultAction`.

Specified by:
  `visitUnionType` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitIntersectionType

    public R visitIntersectionType​(IntersectionTypeTree node,
                                   P p)

Visits an IntersectionTypeTree node. This implementation calls `defaultAction`.

Specified by:
  `visitIntersectionType` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitTypeParameter

    public R visitTypeParameter​(TypeParameterTree node,
                                P p)

Visits a TypeParameterTree node. This implementation calls `defaultAction`.

Specified by:
  `visitTypeParameter` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitWildcard

    public R visitWildcard​(WildcardTree node,
                           P p)

Visits a WildcardTypeTree node. This implementation calls `defaultAction`.

Specified by:
  `visitWildcard` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitModifiers

    public R visitModifiers​(ModifiersTree node,
                            P p)

Visits a ModifiersTree node. This implementation calls `defaultAction`.

Specified by:
  `visitModifiers` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitAnnotation

    public R visitAnnotation​(AnnotationTree node,
                             P p)

Visits an AnnotatedTree node. This implementation calls `defaultAction`.

Specified by:
  `visitAnnotation` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitAnnotatedType

    public R visitAnnotatedType​(AnnotatedTypeTree node,
                                P p)

Visits an AnnotatedTypeTree node. This implementation calls `defaultAction`.

Specified by:
  `visitAnnotatedType` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`

#### visitOther

    public R visitOther​(Tree node,
                        P p)

Visits an unknown type of Tree node. This can occur if the language evolves and new kinds of nodes are added to the `Tree` hierarchy. This implementation calls `defaultAction`.

Specified by:
  `visitOther` in interface `TreeVisitor<R,​P>`
Parameters:
  `node` - the node being visited
  `p` - a parameter value
Returns:
  the result of `defaultAction`