Module jdk.scripting.nashorn
Package jdk.nashorn.api.tree

## Class SimpleTreeVisitorES5_1<R,P>

- java.lang.Object
- - jdk.nashorn.api.tree.SimpleTreeVisitorES5_1<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 SimpleTreeVisitorES5_1<R,P>
    extends Object
    implements TreeVisitor<R,P>

A simple implementation of the TreeVisitor for ECMAScript edition 5.1.

The visit methods corresponding to ES 5.1 language constructs walk the "components" of the given tree by calling accept method passing the current visitor and the additional parameter.

For constructs introduced in later versions, `visitUnknown` is called instead which throws `UnknownTreeException`.

Methods in this class may be overridden subject to their general contract. Note that annotating methods in concrete subclasses with `@Override` will help ensure that methods are overridden as intended.

### Constructor Summary

Constructors
Constructor and Description
`SimpleTreeVisitorES5_1()`

### Method Summary

All Methods Instance Methods Concrete Methods
`R` `visitArrayAccess(ArrayAccessTree node, P r)` Visit array access expression tree.
`R` `visitArrayLiteral(ArrayLiteralTree node, P r)` Visit array literal expression tree.
`R` `visitAssignment(AssignmentTree node, P r)` Visit assignment tree.
`R` `visitBinary(BinaryTree node, P r)` Visit binary expression tree.
`R` `visitBlock(BlockTree node, P r)` Visit block statement tree.
`R` `visitBreak(BreakTree node, P r)` Visit break statement tree.
`R` `visitCase(CaseTree node, P r)` Visit case statement tree.
`R` `visitCatch(CatchTree node, P r)` Visit catch block statement tree.
`R` `visitCompilationUnit(CompilationUnitTree node, P r)` Visit compilation unit tree.
`R` `visitCompoundAssignment(CompoundAssignmentTree node, P r)` Visit compound assignment tree.
`R` `visitConditionalExpression(ConditionalExpressionTree node, P r)` Visit conditional expression tree.
`R` `visitContinue(ContinueTree node, P r)` Visit continue statement tree.
`R` `visitDebugger(DebuggerTree node, P r)` Visit debugger statement tree.
`R` `visitDoWhileLoop(DoWhileLoopTree node, P r)` Visit do-while statement tree.
`R` `visitEmptyStatement(EmptyStatementTree node, P r)` Visit an empty statement tree.
`R` `visitErroneous(ErroneousTree node, P r)` Visit error expression tree.
`R` `visitExpressionStatement(ExpressionStatementTree node, P r)` Visit expression statement tree.
`R` `visitForInLoop(ForInLoopTree node, P r)` Visit for..in statement tree.
`R` `visitForLoop(ForLoopTree node, P r)` Visit 'for' statement tree.
`R` `visitFunctionCall(FunctionCallTree node, P r)` Visit function call expression tree.
`R` `visitFunctionDeclaration(FunctionDeclarationTree node, P r)` Visit function declaration tree.
`R` `visitFunctionExpression(FunctionExpressionTree node, P r)` Visit function expression tree.
`R` `visitIdentifier(IdentifierTree node, P r)` Visit identifier tree.
`R` `visitIf(IfTree node, P r)` Visit 'if' statement tree.
`R` `visitInstanceOf(InstanceOfTree node, P r)` Visit 'instanceof' expression tree.
`R` `visitLabeledStatement(LabeledStatementTree node, P r)` Visit labeled statement tree.
`R` `visitLiteral(LiteralTree node, P r)` Visit literal expression tree.
`R` `visitMemberSelect(MemberSelectTree node, P r)` Visit member select expression tree.
`R` `visitNew(NewTree node, P r)` Visit 'new' expression tree.
`R` `visitObjectLiteral(ObjectLiteralTree node, P r)` Visit object literal tree.
`R` `visitParenthesized(ParenthesizedTree node, P r)` Visit parenthesized expression tree.
`R` `visitProperty(PropertyTree node, P r)` Visit a property of an object literal expression tree.
`R` `visitRegExpLiteral(RegExpLiteralTree node, P r)` Visit regular expression literal tree.
`R` `visitReturn(ReturnTree node, P r)` Visit return statement tree.
`R` `visitSwitch(SwitchTree node, P r)` Visit 'switch' statement tree.
`R` `visitThrow(ThrowTree node, P r)` Visit 'throw' expression tree.
`R` `visitTry(TryTree node, P r)` Visit 'try' statement tree.
`R` `visitUnary(UnaryTree node, P r)` Visit unary expression tree.
`R` `visitUnknown(Tree node, P r)` Visit unknown expression/statement tree.
`R` `visitVariable(VariableTree node, P r)` Visit variable declaration tree.
`R` `visitWhileLoop(WhileLoopTree node, P r)` Visit 'while' statement tree.
`R` `visitWith(WithTree node, P r)` Visit 'with' statement tree.

### Methods inherited from class java.lang.Object

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

### Constructor Detail

#### SimpleTreeVisitorES5_1

    public SimpleTreeVisitorES5_1()

### Method Detail

#### visitAssignment

    public R visitAssignment(AssignmentTree node,
                             P r)

Description copied from interface: `TreeVisitor`
Visit assignment tree.

Specified by:
  `visitAssignment` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitCompoundAssignment

    public R visitCompoundAssignment(CompoundAssignmentTree node,
                                     P r)

Description copied from interface: `TreeVisitor`
Visit compound assignment tree.

Specified by:
  `visitCompoundAssignment` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitBinary

    public R visitBinary(BinaryTree node,
                         P r)

Description copied from interface: `TreeVisitor`
Visit binary expression tree.

Specified by:
  `visitBinary` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitBlock

    public R visitBlock(BlockTree node,
                        P r)

Description copied from interface: `TreeVisitor`
Visit block statement tree.

Specified by:
  `visitBlock` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitBreak

    public R visitBreak(BreakTree node,
                        P r)

Description copied from interface: `TreeVisitor`
Visit break statement tree.

Specified by:
  `visitBreak` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitCase

    public R visitCase(CaseTree node,
                       P r)

Description copied from interface: `TreeVisitor`
Visit case statement tree.

Specified by:
  `visitCase` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitCatch

    public R visitCatch(CatchTree node,
                        P r)

Description copied from interface: `TreeVisitor`
Visit catch block statement tree.

Specified by:
  `visitCatch` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitConditionalExpression

    public R visitConditionalExpression(ConditionalExpressionTree node,
                                        P r)

Description copied from interface: `TreeVisitor`
Visit conditional expression tree.

Specified by:
  `visitConditionalExpression` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitContinue

    public R visitContinue(ContinueTree node,
                           P r)

Description copied from interface: `TreeVisitor`
Visit continue statement tree.

Specified by:
  `visitContinue` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitDebugger

    public R visitDebugger(DebuggerTree node,
                           P r)

Description copied from interface: `TreeVisitor`
Visit debugger statement tree.

Specified by:
  `visitDebugger` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitDoWhileLoop

    public R visitDoWhileLoop(DoWhileLoopTree node,
                              P r)

Description copied from interface: `TreeVisitor`
Visit do-while statement tree.

Specified by:
  `visitDoWhileLoop` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitErroneous

    public R visitErroneous(ErroneousTree node,
                            P r)

Description copied from interface: `TreeVisitor`
Visit error expression tree.

Specified by:
  `visitErroneous` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitExpressionStatement

    public R visitExpressionStatement(ExpressionStatementTree node,
                                      P r)

Description copied from interface: `TreeVisitor`
Visit expression statement tree.

Specified by:
  `visitExpressionStatement` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitForLoop

    public R visitForLoop(ForLoopTree node,
                          P r)

Description copied from interface: `TreeVisitor`
Visit 'for' statement tree.

Specified by:
  `visitForLoop` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitForInLoop

    public R visitForInLoop(ForInLoopTree node,
                            P r)

Description copied from interface: `TreeVisitor`
Visit for..in statement tree.

Specified by:
  `visitForInLoop` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitFunctionCall

    public R visitFunctionCall(FunctionCallTree node,
                               P r)

Description copied from interface: `TreeVisitor`
Visit function call expression tree.

Specified by:
  `visitFunctionCall` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitFunctionDeclaration

    public R visitFunctionDeclaration(FunctionDeclarationTree node,
                                      P r)

Description copied from interface: `TreeVisitor`
Visit function declaration tree.

Specified by:
  `visitFunctionDeclaration` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitFunctionExpression

    public R visitFunctionExpression(FunctionExpressionTree node,
                                     P r)

Description copied from interface: `TreeVisitor`
Visit function expression tree.

Specified by:
  `visitFunctionExpression` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitIdentifier

    public R visitIdentifier(IdentifierTree node,
                             P r)

Description copied from interface: `TreeVisitor`
Visit identifier tree.

Specified by:
  `visitIdentifier` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitIf

    public R visitIf(IfTree node,
                     P r)

Description copied from interface: `TreeVisitor`
Visit 'if' statement tree.

Specified by:
  `visitIf` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitArrayAccess

    public R visitArrayAccess(ArrayAccessTree node,
                              P r)

Description copied from interface: `TreeVisitor`
Visit array access expression tree.

Specified by:
  `visitArrayAccess` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitArrayLiteral

    public R visitArrayLiteral(ArrayLiteralTree node,
                               P r)

Description copied from interface: `TreeVisitor`
Visit array literal expression tree.

Specified by:
  `visitArrayLiteral` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitLabeledStatement

    public R visitLabeledStatement(LabeledStatementTree node,
                                   P r)

Description copied from interface: `TreeVisitor`
Visit labeled statement tree.

Specified by:
  `visitLabeledStatement` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitLiteral

    public R visitLiteral(LiteralTree node,
                          P r)

Description copied from interface: `TreeVisitor`
Visit literal expression tree.

Specified by:
  `visitLiteral` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitParenthesized

    public R visitParenthesized(ParenthesizedTree node,
                                P r)

Description copied from interface: `TreeVisitor`
Visit parenthesized expression tree.

Specified by:
  `visitParenthesized` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitReturn

    public R visitReturn(ReturnTree node,
                         P r)

Description copied from interface: `TreeVisitor`
Visit return statement tree.

Specified by:
  `visitReturn` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitMemberSelect

    public R visitMemberSelect(MemberSelectTree node,
                               P r)

Description copied from interface: `TreeVisitor`
Visit member select expression tree.

Specified by:
  `visitMemberSelect` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitNew

    public R visitNew(NewTree node,
                      P r)

Description copied from interface: `TreeVisitor`
Visit 'new' expression tree.

Specified by:
  `visitNew` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitObjectLiteral

    public R visitObjectLiteral(ObjectLiteralTree node,
                                P r)

Description copied from interface: `TreeVisitor`
Visit object literal tree.

Specified by:
  `visitObjectLiteral` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitProperty

    public R visitProperty(PropertyTree node,
                           P r)

Description copied from interface: `TreeVisitor`
Visit a property of an object literal expression tree.

Specified by:
  `visitProperty` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitRegExpLiteral

    public R visitRegExpLiteral(RegExpLiteralTree node,
                                P r)

Description copied from interface: `TreeVisitor`
Visit regular expression literal tree.

Specified by:
  `visitRegExpLiteral` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitEmptyStatement

    public R visitEmptyStatement(EmptyStatementTree node,
                                 P r)

Description copied from interface: `TreeVisitor`
Visit an empty statement tree.

Specified by:
  `visitEmptyStatement` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitSwitch

    public R visitSwitch(SwitchTree node,
                         P r)

Description copied from interface: `TreeVisitor`
Visit 'switch' statement tree.

Specified by:
  `visitSwitch` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitThrow

    public R visitThrow(ThrowTree node,
                        P r)

Description copied from interface: `TreeVisitor`
Visit 'throw' expression tree.

Specified by:
  `visitThrow` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitCompilationUnit

    public R visitCompilationUnit(CompilationUnitTree node,
                                  P r)

Description copied from interface: `TreeVisitor`
Visit compilation unit tree.

Specified by:
  `visitCompilationUnit` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitTry

    public R visitTry(TryTree node,
                      P r)

Description copied from interface: `TreeVisitor`
Visit 'try' statement tree.

Specified by:
  `visitTry` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitInstanceOf

    public R visitInstanceOf(InstanceOfTree node,
                             P r)

Description copied from interface: `TreeVisitor`
Visit 'instanceof' expression tree.

Specified by:
  `visitInstanceOf` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitUnary

    public R visitUnary(UnaryTree node,
                        P r)

Description copied from interface: `TreeVisitor`
Visit unary expression tree.

Specified by:
  `visitUnary` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitVariable

    public R visitVariable(VariableTree node,
                           P r)

Description copied from interface: `TreeVisitor`
Visit variable declaration tree.

Specified by:
  `visitVariable` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitWhileLoop

    public R visitWhileLoop(WhileLoopTree node,
                            P r)

Description copied from interface: `TreeVisitor`
Visit 'while' statement tree.

Specified by:
  `visitWhileLoop` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitWith

    public R visitWith(WithTree node,
                       P r)

Description copied from interface: `TreeVisitor`
Visit 'with' statement tree.

Specified by:
  `visitWith` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor

#### visitUnknown

    public R visitUnknown(Tree node,
                          P r)

Description copied from interface: `TreeVisitor`
Visit unknown expression/statement tree. This fallback will be called if new Tree subtypes are introduced in future. A specific implementation may throw {unknown tree exception if the visitor implementation was for an older language version.

Specified by:
  `visitUnknown` in interface `TreeVisitor<R,P>`
Parameters:
  `node` - node being visited
  `r` - extra parameter passed to the visitor
Returns:
  value from the visitor