Package org.openrewrite.java

Class JavaVisitor<P>

java.lang.Object
org.openrewrite.TreeVisitor<J,P>
org.openrewrite.java.JavaVisitor<P>
Direct Known Subclasses:
CountLinesVisitor, ExtractField, InvertCondition, JavaIsoVisitor, JavaPrinter, NoMissingTypes, UnwrapParentheses
public class JavaVisitor<P> extends org.openrewrite.TreeVisitor<J,P>

  • Field Details

    • javadocVisitor

      @Nullable protected @Nullable JavadocVisitor<P> javadocVisitor

  • Constructor Details

    • JavaVisitor

      public JavaVisitor()

  • Method Details

    • isAcceptable

      public boolean isAcceptable(org.openrewrite.SourceFile sourceFile, P p)
      Overrides:
      isAcceptable in class org.openrewrite.TreeVisitor<J,P>

    • getLanguage

      public String getLanguage()
      Overrides:
      getLanguage in class org.openrewrite.TreeVisitor<J,P>

    • getJavadocVisitor

      protected JavadocVisitor<P> getJavadocVisitor()
      This method returns a new instance of a Javadoc visitor that will be used by this JavaVisitor.
      Returns:
      The JavadocVisitor associated with the JavaVisitor.

    • 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.

    • maybeAutoFormat

      public <J2 extends J> J2 maybeAutoFormat(J2 before, J2 after, P p)

    • maybeAutoFormat

      public <J2 extends J> J2 maybeAutoFormat(J2 before, J2 after, P p, org.openrewrite.Cursor cursor)

    • maybeAutoFormat

      public <J2 extends J> J2 maybeAutoFormat(J2 before, J2 after, @Nullable @Nullable J stopAfter, P p, org.openrewrite.Cursor cursor)

    • autoFormat

      public <J2 extends J> J2 autoFormat(J2 j, P p)

    • autoFormat

      public <J2 extends J> J2 autoFormat(J2 j, P p, org.openrewrite.Cursor cursor)

    • autoFormat

      public <J2 extends J> J2 autoFormat(J2 j, @Nullable @Nullable J stopAfter, P p, org.openrewrite.Cursor cursor)

    • maybeAddImport

      public void maybeAddImport(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(String fullyQualifiedName, String statik)
      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.
      statik - The static method or field to be imported. A wildcard "*" may also be used to statically import all methods/fields.

    • maybeAddImport

      public void maybeAddImport(String fullyQualifiedName, boolean onlyIfReferenced)

    • maybeAddImport

      public void maybeAddImport(String fullyQualifiedName, @Nullable @Nullable String statik, boolean onlyIfReferenced)

    • maybeRemoveImport

      public void maybeRemoveImport(@Nullable JavaType.FullyQualified clazz)

    • maybeRemoveImport

      public void maybeRemoveImport(String fullyQualifiedName)

    • visitExpression

      public J visitExpression(Expression expression, P p)

    • visitStatement

      public J visitStatement(Statement statement, P p)

    • visitSpace

      public Space visitSpace(Space space, Space.Location loc, P p)

    • visitType

      @Nullable public @Nullable JavaType visitType(@Nullable @Nullable JavaType javaType, P p)

    • visitTypeName

      public <N extends NameTree> N visitTypeName(N nameTree, P p)

    • visitAnnotatedType

      public J visitAnnotatedType(J.AnnotatedType annotatedType, P p)

    • visitAnnotation

      public J visitAnnotation(J.Annotation annotation, P p)

    • visitArrayAccess

      public J visitArrayAccess(J.ArrayAccess arrayAccess, P p)

    • visitArrayDimension

      public J visitArrayDimension(J.ArrayDimension arrayDimension, P p)

    • visitArrayType

      public J visitArrayType(J.ArrayType arrayType, P p)

    • visitAssert

      public J visitAssert(J.Assert azzert, P p)

    • visitAssignment

      public J visitAssignment(J.Assignment assignment, P p)

    • visitAssignmentOperation

      public J visitAssignmentOperation(J.AssignmentOperation assignOp, P p)

    • visitBinary

      public J visitBinary(J.Binary binary, P p)

    • visitBlock

      public J visitBlock(J.Block block, P p)

    • visitBreak

      public J visitBreak(J.Break breakStatement, P p)

    • visitCase

      public J visitCase(J.Case caze, P p)

    • visitCatch

      public J visitCatch(J.Try.Catch catzh, P p)

    • visitClassDeclaration

      public J visitClassDeclaration(J.ClassDeclaration classDecl, P p)

    • visitCompilationUnit

      public J visitCompilationUnit(J.CompilationUnit cu, P p)

    • visitContinue

      public J visitContinue(J.Continue continueStatement, P p)

    • visitControlParentheses

      public <T extends J> J visitControlParentheses(J.ControlParentheses<T> controlParens, P p)

    • visitDoWhileLoop

      public J visitDoWhileLoop(J.DoWhileLoop doWhileLoop, P p)

    • visitEmpty

      public J visitEmpty(J.Empty empty, P p)

    • visitEnumValue

      public J visitEnumValue(J.EnumValue enoom, P p)

    • visitEnumValueSet

      public J visitEnumValueSet(J.EnumValueSet enums, P p)

    • visitFieldAccess

      public J visitFieldAccess(J.FieldAccess fieldAccess, P p)

    • visitForEachLoop

      public J visitForEachLoop(J.ForEachLoop forLoop, P p)

    • visitForEachControl

      public J visitForEachControl(J.ForEachLoop.Control control, P p)

    • visitForLoop

      public J visitForLoop(J.ForLoop forLoop, P p)

    • visitForControl

      public J visitForControl(J.ForLoop.Control control, P p)

    • visitIdentifier

      public J visitIdentifier(J.Identifier ident, P p)

    • visitElse

      public J visitElse(J.If.Else elze, P p)

    • visitIf

      public J visitIf(J.If iff, P p)

    • visitImport

      public J visitImport(J.Import impoort, P p)

    • visitInstanceOf

      public J visitInstanceOf(J.InstanceOf instanceOf, P p)

    • visitLabel

      public J visitLabel(J.Label label, P p)

    • visitLambda

      public J visitLambda(J.Lambda lambda, P p)

    • visitLiteral

      public J visitLiteral(J.Literal literal, P p)

    • visitMemberReference

      public J visitMemberReference(J.MemberReference memberRef, P p)

    • visitMethodDeclaration

      public J visitMethodDeclaration(J.MethodDeclaration method, P p)

    • visitMethodInvocation

      public J visitMethodInvocation(J.MethodInvocation method, P p)

    • visitMultiCatch

      public J visitMultiCatch(J.MultiCatch multiCatch, P p)

    • visitVariableDeclarations

      public J visitVariableDeclarations(J.VariableDeclarations multiVariable, P p)

    • visitNewArray

      public J visitNewArray(J.NewArray newArray, P p)

    • visitNewClass

      public J visitNewClass(J.NewClass newClass, P p)

    • visitPackage

      public J visitPackage(J.Package pkg, P p)

    • visitParameterizedType

      public J visitParameterizedType(J.ParameterizedType type, P p)

    • visitParentheses

      public <T extends J> J visitParentheses(J.Parentheses<T> parens, P p)

    • visitPrimitive

      public J visitPrimitive(J.Primitive primitive, P p)

    • visitReturn

      public J visitReturn(J.Return retrn, P p)

    • visitSwitch

      public J visitSwitch(J.Switch switzh, P p)

    • visitSwitchExpression

      public J visitSwitchExpression(J.SwitchExpression switzh, P p)

    • visitSynchronized

      public J visitSynchronized(J.Synchronized synch, P p)

    • visitTernary

      public J visitTernary(J.Ternary ternary, P p)

    • visitThrow

      public J visitThrow(J.Throw thrown, P p)

    • visitTry

      public J visitTry(J.Try tryable, P p)

    • visitTryResource

      public J visitTryResource(J.Try.Resource tryResource, P p)

    • visitTypeCast

      public J visitTypeCast(J.TypeCast typeCast, P p)

    • visitTypeParameter

      public J visitTypeParameter(J.TypeParameter typeParam, P p)

    • visitUnary

      public J visitUnary(J.Unary unary, P p)

    • visitVariable

      public J visitVariable(J.VariableDeclarations.NamedVariable variable, P p)

    • visitWhileLoop

      public J visitWhileLoop(J.WhileLoop whileLoop, P p)

    • visitWildcard

      public J visitWildcard(J.Wildcard wildcard, P p)

    • visitYield

      public J visitYield(J.Yield yield, P p)

    • visitRightPadded

      public <T> JRightPadded<T> visitRightPadded(@Nullable @Nullable JRightPadded<T> right, JRightPadded.Location loc, P p)

    • visitLeftPadded

      public <T> JLeftPadded<T> visitLeftPadded(@Nullable @Nullable JLeftPadded<T> left, JLeftPadded.Location loc, P p)

    • visitContainer

      public <J2 extends J> JContainer<J2> visitContainer(@Nullable @Nullable JContainer<J2> container, JContainer.Location loc, P p)

    • isInSameNameScope

      protected boolean isInSameNameScope(org.openrewrite.Cursor base, org.openrewrite.Cursor child)
      Check if a child AST element is in the same lexical scope as that of the AST element associated with the base cursor. (i.e.: Are the variables and declarations visible in the base scope also visible to the child AST element?)

      The base lexical scope is first established by walking up the path of the base cursor to find its first enclosing element. The child path is traversed by walking up the child path elements until either the base scope has been found, a "terminating" element is encountered, or there are no more elements in the path.

      A terminating element is one of the following:

    • A static class declaration
    • An enumeration declaration
    • An interface declaration
    • An annotation declaration
      • Parameters:
      base - A pointer within the AST that is used to establish the "base lexical scope".
      child - A pointer within the AST that will be traversed (up the tree) looking for an intersection with the base lexical scope.
      Returns:
      true if the child is in within the lexical scope of the base

    • isInSameNameScope

      protected boolean isInSameNameScope(org.openrewrite.Cursor child)
      Check if a child AST element is in the same lexical scope as that of the AST element associated with the current cursor.

      See isInSameNameScope(org.openrewrite.Cursor, org.openrewrite.Cursor)

      Parameters:
      child - A pointer to an element within the abstract syntax tree
      Returns:
      true if the child is in within the lexical scope of the current cursor

    • describeLocation

      @Nullable protected @Nullable String describeLocation(org.openrewrite.Cursor cursor)
      Overrides:
      describeLocation in class org.openrewrite.TreeVisitor<J,P>