Compiler Tree API

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

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
 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 visitLabeledStatement(LabeledStatementTree node, P p)
           
 R visitLiteral(LiteralTree 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 visitVariable(VariableTree node, P p)
           
 R visitWhileLoop(WhileLoopTree node, P p)
           
 R visitWildcard(WildcardTree node, P p)
           
 

Method Detail

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)

visitParenthesized

R visitParenthesized(ParenthesizedTree node,
                     P p)

visitReturn

R visitReturn(ReturnTree node,
              P p)

visitMemberSelect

R visitMemberSelect(MemberSelectTree 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)

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)

Compiler Tree API

Submit a bug or feature
Copyright © 2005, 2011, Oracle and/or its affiliates. All rights reserved.