java.lang.Object
- org.openrewrite.AbstractSourceVisitor<T>
- - org.openrewrite.AbstractRefactorVisitor<J>
  - - org.openrewrite.java.JavaRefactorVisitor

All Implemented Interfaces:

JavaSourceVisitor<J>, org.openrewrite.RefactorVisitor<J>, org.openrewrite.SourceVisitor<J>

Direct Known Subclasses:

JavaIsoRefactorVisitor, UnwrapParentheses.Scoped
```
public class JavaRefactorVisitor
extends org.openrewrite.AbstractRefactorVisitor<J>
implements JavaSourceVisitor<J>
```
This is the class you want to extend from if your visitor might ever want to swap the AST element being visited for a different type of AST element. For example visiting a method declaration and returning a field. Most visitors do not need this flexibility and can extend JavaIsomorphicRefactorVisitor whose type signatures insist that when visiting an AST element the returned element must be of the same type.

Field Summary

Fields
Modifier and Type Field Description

protected JavaFormatter formatter

protected TreeBuilder treeBuilder

Constructor Summary

Constructors
Constructor Description

JavaRefactorVisitor()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addImport(java.lang.String fullyQualifiedName)`	This method will add an import to the compilation unit regardless if a reference to the type exists.
`void`	`addImport(java.lang.String fullyQualifiedName, java.lang.String staticMethod)`	This method will add an import to the compilation unit regardless if a reference to the type/method exists.
`void`	`maybeAddImport(java.lang.String fullyQualifiedName)`	This method will add an import to the compilation unit if there is a reference to the type.
`void`	`maybeAddImport(java.lang.String fullyQualifiedName, java.lang.String staticMethod)`	This method will add a static import to the compilation unit if there is a reference to the type/method.
`void`	`maybeAddImport(JavaType.FullyQualified clazz)`	This method will add an import to the compilation unit if there is a reference to the type.
`void`	`maybeRemoveImport(java.lang.String fullyQualifiedName)`
`void`	`maybeRemoveImport(JavaType.FullyQualified clazz)`
`void`	`maybeUnwrapParentheses(org.openrewrite.Cursor parensCursor)`
`J`	`visitAnnotatedType(J.AnnotatedType annotatedType)`
`J`	`visitAnnotation(J.Annotation annotation)`
`J`	`visitArrayAccess(J.ArrayAccess arrayAccess)`
`J`	`visitArrayType(J.ArrayType arrayType)`
`J`	`visitAssert(J.Assert azzert)`
`J`	`visitAssign(J.Assign assign)`
`J`	`visitAssignOp(J.AssignOp assignOp)`
`J`	`visitBinary(J.Binary binary)`
`J`	`visitBlock(J.Block<J> block)`
`J`	`visitBreak(J.Break breakStatement)`
`J`	`visitCase(J.Case caze)`
`J`	`visitCatch(J.Try.Catch catzh)`
`J`	`visitClassDecl(J.ClassDecl classDecl)`
`J`	`visitCompilationUnit(J.CompilationUnit cu)`
`J`	`visitContinue(J.Continue continueStatement)`
`J`	`visitDoWhileLoop(J.DoWhileLoop doWhileLoop)`
`J`	`visitElse(J.If.Else elze)`
`J`	`visitEmpty(J.Empty empty)`
`J`	`visitEnumValue(J.EnumValue enoom)`
`J`	`visitEnumValueSet(J.EnumValueSet enums)`
`J`	`visitFieldAccess(J.FieldAccess fieldAccess)`
`J`	`visitFinally(J.Try.Finally finallie)`
`J`	`visitForEachLoop(J.ForEachLoop forLoop)`
`J`	`visitForLoop(J.ForLoop forLoop)`
`J`	`visitIdentifier(J.Ident ident)`
`J`	`visitIf(J.If iff)`
`J`	`visitImport(J.Import impoort)`
`J`	`visitInstanceOf(J.InstanceOf instanceOf)`
`J`	`visitLabel(J.Label label)`
`J`	`visitLambda(J.Lambda lambda)`
`J`	`visitLiteral(J.Literal literal)`
`J`	`visitMemberReference(J.MemberReference memberRef)`
`J`	`visitMethod(J.MethodDecl method)`
`J`	`visitMethodInvocation(J.MethodInvocation method)`
`J`	`visitMultiCatch(J.MultiCatch multiCatch)`
`J`	`visitMultiVariable(J.VariableDecls multiVariable)`
`J`	`visitNewArray(J.NewArray newArray)`
`J`	`visitNewClass(J.NewClass newClass)`
`J`	`visitPackage(J.Package pkg)`
`J`	`visitParameterizedType(J.ParameterizedType type)`
`<T extends J> J`	`visitParentheses(J.Parentheses<T> parens)`
`J`	`visitPrimitive(J.Primitive primitive)`
`J`	`visitReturn(J.Return retrn)`
`J`	`visitStatement(Statement statement)`
`J`	`visitSwitch(J.Switch switzh)`
`J`	`visitSynchronized(J.Synchronized synch)`
`J`	`visitTernary(J.Ternary ternary)`
`J`	`visitThrow(J.Throw thrown)`
`J`	`visitTry(J.Try tryable)`
`J`	`visitTypeCast(J.TypeCast typeCast)`
`J`	`visitTypeName(NameTree name)`
`J`	`visitTypeParameter(J.TypeParameter typeParam)`
`J`	`visitTypeParameters(J.TypeParameters typeParams)`
`J`	`visitUnary(J.Unary unary)`
`J`	`visitUnparsedSource(J.UnparsedSource unparsed)`
`J`	`visitVariable(J.VariableDecls.NamedVar variable)`
`J`	`visitWhileLoop(J.WhileLoop whileLoop)`
`J`	`visitWildcard(J.Wildcard wildcard)`

Methods inherited from class org.openrewrite.AbstractRefactorVisitor
andThen, andThen, next, refactor, refactor, refactor

Methods inherited from class org.openrewrite.AbstractSourceVisitor
getCursor, setCursoringOn, visit, visitAfter, visitAfter

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.openrewrite.java.JavaSourceVisitor
enclosingBlock, enclosingClass, enclosingCompilationUnit, enclosingMethod, isInSameNameScope, isInSameNameScope, visitExpression

Methods inherited from interface org.openrewrite.RefactorVisitor
defaultTo, generate, isIdempotent, nextCycle

Methods inherited from interface org.openrewrite.SourceVisitor
getCursor, getName, getTags, reduce, validate, visit, visit, visitTree

- Field Detail
  - formatter
```
protected JavaFormatter formatter
```
  - treeBuilder
```
protected TreeBuilder treeBuilder
```
- Constructor Detail
  - JavaRefactorVisitor
```
public JavaRefactorVisitor()
```
- Method Detail
  - visitStatement
```
public J visitStatement(Statement statement)
```
    Specified by:
    
    visitStatement in interface JavaSourceVisitor<J>
  - visitTypeName
```
public J visitTypeName(NameTree name)
```
    Specified by:
    
    visitTypeName in interface JavaSourceVisitor<J>
  - visitAnnotatedType
```
public J visitAnnotatedType(J.AnnotatedType annotatedType)
```
    Specified by:
    
    visitAnnotatedType in interface JavaSourceVisitor<J>
  - visitAnnotation
```
public J visitAnnotation(J.Annotation annotation)
```
    Specified by:
    
    visitAnnotation in interface JavaSourceVisitor<J>
  - visitArrayAccess
```
public J visitArrayAccess(J.ArrayAccess arrayAccess)
```
    Specified by:
    
    visitArrayAccess in interface JavaSourceVisitor<J>
  - visitArrayType
```
public J visitArrayType(J.ArrayType arrayType)
```
    Specified by:
    
    visitArrayType in interface JavaSourceVisitor<J>
  - visitAssert
```
public J visitAssert(J.Assert azzert)
```
    Specified by:
    
    visitAssert in interface JavaSourceVisitor<J>
  - visitAssign
```
public J visitAssign(J.Assign assign)
```
    Specified by:
    
    visitAssign in interface JavaSourceVisitor<J>
  - visitAssignOp
```
public J visitAssignOp(J.AssignOp assignOp)
```
    Specified by:
    
    visitAssignOp in interface JavaSourceVisitor<J>
  - visitBinary
```
public J visitBinary(J.Binary binary)
```
    Specified by:
    
    visitBinary in interface JavaSourceVisitor<J>
  - visitBlock
```
public J visitBlock(J.Block<J> block)
```
    Specified by:
    
    visitBlock in interface JavaSourceVisitor<J>
  - visitBreak
```
public J visitBreak(J.Break breakStatement)
```
    Specified by:
    
    visitBreak in interface JavaSourceVisitor<J>
  - visitCase
```
public J visitCase(J.Case caze)
```
    Specified by:
    
    visitCase in interface JavaSourceVisitor<J>
  - visitCatch
```
public J visitCatch(J.Try.Catch catzh)
```
    Specified by:
    
    visitCatch in interface JavaSourceVisitor<J>
  - visitClassDecl
```
public J visitClassDecl(J.ClassDecl classDecl)
```
    Specified by:
    
    visitClassDecl in interface JavaSourceVisitor<J>
  - visitCompilationUnit
```
public J visitCompilationUnit(J.CompilationUnit cu)
```
    Specified by:
    
    visitCompilationUnit in interface JavaSourceVisitor<J>
  - visitContinue
```
public J visitContinue(J.Continue continueStatement)
```
    Specified by:
    
    visitContinue in interface JavaSourceVisitor<J>
  - visitDoWhileLoop
```
public J visitDoWhileLoop(J.DoWhileLoop doWhileLoop)
```
    Specified by:
    
    visitDoWhileLoop in interface JavaSourceVisitor<J>
  - visitEmpty
```
public J visitEmpty(J.Empty empty)
```
    Specified by:
    
    visitEmpty in interface JavaSourceVisitor<J>
  - visitEnumValue
```
public J visitEnumValue(J.EnumValue enoom)
```
    Specified by:
    
    visitEnumValue in interface JavaSourceVisitor<J>
  - visitEnumValueSet
```
public J visitEnumValueSet(J.EnumValueSet enums)
```
    Specified by:
    
    visitEnumValueSet in interface JavaSourceVisitor<J>
  - visitFieldAccess
```
public J visitFieldAccess(J.FieldAccess fieldAccess)
```
    Specified by:
    
    visitFieldAccess in interface JavaSourceVisitor<J>
  - visitFinally
```
public J visitFinally(J.Try.Finally finallie)
```
    Specified by:
    
    visitFinally in interface JavaSourceVisitor<J>
  - visitForEachLoop
```
public J visitForEachLoop(J.ForEachLoop forLoop)
```
    Specified by:
    
    visitForEachLoop in interface JavaSourceVisitor<J>
  - visitForLoop
```
public J visitForLoop(J.ForLoop forLoop)
```
    Specified by:
    
    visitForLoop in interface JavaSourceVisitor<J>
  - visitIdentifier
```
public J visitIdentifier(J.Ident ident)
```
    Specified by:
    
    visitIdentifier in interface JavaSourceVisitor<J>
  - visitIf
```
public J visitIf(J.If iff)
```
    Specified by:
    
    visitIf in interface JavaSourceVisitor<J>
  - visitElse
```
public J visitElse(J.If.Else elze)
```
    Specified by:
    
    visitElse in interface JavaSourceVisitor<J>
  - visitImport
```
public J visitImport(J.Import impoort)
```
    Specified by:
    
    visitImport in interface JavaSourceVisitor<J>
  - visitInstanceOf
```
public J visitInstanceOf(J.InstanceOf instanceOf)
```
    Specified by:
    
    visitInstanceOf in interface JavaSourceVisitor<J>
  - visitLabel
```
public J visitLabel(J.Label label)
```
    Specified by:
    
    visitLabel in interface JavaSourceVisitor<J>
  - visitLambda
```
public J visitLambda(J.Lambda lambda)
```
    Specified by:
    
    visitLambda in interface JavaSourceVisitor<J>
  - visitLiteral
```
public J visitLiteral(J.Literal literal)
```
    Specified by:
    
    visitLiteral in interface JavaSourceVisitor<J>
  - visitMemberReference
```
public J visitMemberReference(J.MemberReference memberRef)
```
    Specified by:
    
    visitMemberReference in interface JavaSourceVisitor<J>
  - visitMethod
```
public J visitMethod(J.MethodDecl method)
```
    Specified by:
    
    visitMethod in interface JavaSourceVisitor<J>
  - visitMethodInvocation
```
public J visitMethodInvocation(J.MethodInvocation method)
```
    Specified by:
    
    visitMethodInvocation in interface JavaSourceVisitor<J>
  - visitMultiCatch
```
public J visitMultiCatch(J.MultiCatch multiCatch)
```
    Specified by:
    
    visitMultiCatch in interface JavaSourceVisitor<J>
  - visitMultiVariable
```
public J visitMultiVariable(J.VariableDecls multiVariable)
```
    Specified by:
    
    visitMultiVariable in interface JavaSourceVisitor<J>
  - visitNewArray
```
public J visitNewArray(J.NewArray newArray)
```
    Specified by:
    
    visitNewArray in interface JavaSourceVisitor<J>
  - visitNewClass
```
public J visitNewClass(J.NewClass newClass)
```
    Specified by:
    
    visitNewClass in interface JavaSourceVisitor<J>
  - visitPackage
```
public J visitPackage(J.Package pkg)
```
    Specified by:
    
    visitPackage in interface JavaSourceVisitor<J>
  - visitParameterizedType
```
public J visitParameterizedType(J.ParameterizedType type)
```
    Specified by:
    
    visitParameterizedType in interface JavaSourceVisitor<J>
  - visitParentheses
```
public <T extends J> J visitParentheses(J.Parentheses<T> parens)
```
    Specified by:
    
    visitParentheses in interface JavaSourceVisitor<J>
  - visitPrimitive
```
public J visitPrimitive(J.Primitive primitive)
```
    Specified by:
    
    visitPrimitive in interface JavaSourceVisitor<J>
  - visitReturn
```
public J visitReturn(J.Return retrn)
```
    Specified by:
    
    visitReturn in interface JavaSourceVisitor<J>
  - visitSwitch
```
public J visitSwitch(J.Switch switzh)
```
    Specified by:
    
    visitSwitch in interface JavaSourceVisitor<J>
  - visitSynchronized
```
public J visitSynchronized(J.Synchronized synch)
```
    Specified by:
    
    visitSynchronized in interface JavaSourceVisitor<J>
  - visitTernary
```
public J visitTernary(J.Ternary ternary)
```
    Specified by:
    
    visitTernary in interface JavaSourceVisitor<J>
  - visitThrow
```
public J visitThrow(J.Throw thrown)
```
    Specified by:
    
    visitThrow in interface JavaSourceVisitor<J>
  - visitTry
```
public J visitTry(J.Try tryable)
```
    Specified by:
    
    visitTry in interface JavaSourceVisitor<J>
  - visitTypeCast
```
public J visitTypeCast(J.TypeCast typeCast)
```
    Specified by:
    
    visitTypeCast in interface JavaSourceVisitor<J>
  - visitTypeParameter
```
public J visitTypeParameter(J.TypeParameter typeParam)
```
    Specified by:
    
    visitTypeParameter in interface JavaSourceVisitor<J>
  - visitTypeParameters
```
public J visitTypeParameters(J.TypeParameters typeParams)
```
    Specified by:
    
    visitTypeParameters in interface JavaSourceVisitor<J>
  - visitUnary
```
public J visitUnary(J.Unary unary)
```
    Specified by:
    
    visitUnary in interface JavaSourceVisitor<J>
  - visitUnparsedSource
```
public J visitUnparsedSource(J.UnparsedSource unparsed)
```
    Specified by:
    
    visitUnparsedSource in interface JavaSourceVisitor<J>
  - visitVariable
```
public J visitVariable(J.VariableDecls.NamedVar variable)
```
    Specified by:
    
    visitVariable in interface JavaSourceVisitor<J>
  - visitWhileLoop
```
public J visitWhileLoop(J.WhileLoop whileLoop)
```
    Specified by:
    
    visitWhileLoop in interface JavaSourceVisitor<J>
  - visitWildcard
```
public J visitWildcard(J.Wildcard wildcard)
```
    Specified by:
    
    visitWildcard in interface JavaSourceVisitor<J>
  - addImport
```
public void addImport(java.lang.String fullyQualifiedName)
```
    This method will add an import to the compilation unit regardless if a reference to the type exists. It adds an additional visitor which means the "add import" is deferred and does not complete immediately. This operation is idempotent and calling this method multiple times with the same arguments will only add an import once.
    
    Parameters:
    
    fullyQualifiedName - Fully-qualified name of the class.
  - addImport
```
public void addImport(java.lang.String fullyQualifiedName,
                      java.lang.String staticMethod)
```
    This method will add an import to the compilation unit regardless if a reference to the type/method exists. It adds an additional visitor which means the "add import" is deferred and does not complete immediately. This operation is idempotent and calling this method multiple times with the same arguments will only add an import once.
    
    Parameters:
    
    fullyQualifiedName - Fully-qualified name of the class.
    
    staticMethod - The static method to be imported. A wildcard "*" may also be used to statically import all methods.
  - maybeAddImport
```
public void maybeAddImport(@Nullable
                           JavaType.FullyQualified clazz)
```
    This method will add an import to the compilation unit if there is a reference to the type. It adds an additional visitor which means the "add import" is deferred and does not complete immediately. This operation is idempotent and calling this method multiple times with the same arguments will only add an import once.
    
    Parameters:
    
    clazz - The class that will be imported into the compilation unit.
  - maybeAddImport
```
public void maybeAddImport(java.lang.String fullyQualifiedName)
```
    This method will add an import to the compilation unit if there is a reference to the type. It adds an additional visitor which means the "add import" is deferred and does not complete immediately. This operation is idempotent and calling this method multiple times with the same arguments will only add an import once.
    
    Parameters:
    
    fullyQualifiedName - Fully-qualified name of the class.
  - maybeAddImport
```
public void maybeAddImport(@NonNull
                           java.lang.String fullyQualifiedName,
                           @NonNull
                           java.lang.String staticMethod)
```
    This method will add a static import to the compilation unit if there is a reference to the type/method. It adds an additional visitor which means the "add import" is deferred and does not complete immediately. This operation is idempotent and calling this method multiple times with the same arguments will only add an import once.
    
    Parameters:
    
    fullyQualifiedName - Fully-qualified name of the class.
    
    staticMethod - The static method to be imported. A wildcard "*" may also be used to statically import all methods.
  - maybeRemoveImport
```
public void maybeRemoveImport(@Nullable
                              JavaType.FullyQualified clazz)
```
  - maybeRemoveImport
```
public void maybeRemoveImport(java.lang.String fullyQualifiedName)
```
  - maybeUnwrapParentheses
```
public void maybeUnwrapParentheses(org.openrewrite.Cursor parensCursor)
```

Modifier and Type	Field	Description
`protected JavaFormatter`	`formatter`
`protected TreeBuilder`	`treeBuilder`

Class JavaRefactorVisitor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.openrewrite.AbstractRefactorVisitor

Methods inherited from class org.openrewrite.AbstractSourceVisitor

Methods inherited from class java.lang.Object

Methods inherited from interface org.openrewrite.java.JavaSourceVisitor

Methods inherited from interface org.openrewrite.RefactorVisitor

Methods inherited from interface org.openrewrite.SourceVisitor

Field Detail

formatter

treeBuilder

Constructor Detail

JavaRefactorVisitor

Method Detail

visitStatement

visitTypeName

visitAnnotatedType

visitAnnotation

visitArrayAccess

visitArrayType

visitAssert

visitAssign

visitAssignOp

visitBinary

visitBlock

visitBreak

visitCase

visitCatch

visitClassDecl

visitCompilationUnit

visitContinue

visitDoWhileLoop

visitEmpty

visitEnumValue

visitEnumValueSet

visitFieldAccess

visitFinally

visitForEachLoop

visitForLoop

visitIdentifier

visitIf

visitElse

visitImport

visitInstanceOf

visitLabel

visitLambda

visitLiteral

visitMemberReference

visitMethod

visitMethodInvocation

visitMultiCatch

visitMultiVariable

visitNewArray

visitNewClass

visitPackage

visitParameterizedType

visitParentheses

visitPrimitive

visitReturn

visitSwitch

visitSynchronized

visitTernary

visitThrow

visitTry

visitTypeCast

visitTypeParameter

visitTypeParameters

visitUnary

visitUnparsedSource

visitVariable

visitWhileLoop

visitWildcard

addImport

addImport

maybeAddImport

maybeAddImport

maybeAddImport

maybeRemoveImport