From e57dac0991cf3e57edf99826d975c079d0971baf Mon Sep 17 00:00:00 2001 From: Tim te Beek Date: Fri, 8 Dec 2023 20:16:27 +0000 Subject: [PATCH] refactor: OpenRewrite recipe best practices Use this link to re-run the recipe: https://app.moderne.io/recipes/builder/XX1hrwagC?organizationId=T3BlblJld3JpdGU%3D Co-authored-by: Moderne --- .../AddSerialVersionUidToSerializable.java | 4 +-- .../AtomicPrimitiveEqualsUsesGet.java | 4 +-- .../AvoidBoxedBooleanExpressions.java | 4 +-- .../BigDecimalRoundingConstantsToEnums.java | 4 +-- .../CatchClauseOnlyRethrows.java | 4 +-- .../CombineSemanticallyEqualCatchBlocks.java | 24 ++++++++--------- .../ControlFlowIndentation.java | 6 ++--- .../ExternalizableHasNoArgsConstructor.java | 4 +-- .../FinalizeLocalVariables.java | 6 ++--- .../FinalizeMethodArguments.java | 6 ++--- .../FixStringFormatExpressions.java | 4 +-- .../ForLoopIncrementInUpdate.java | 4 +-- .../staticanalysis/InlineVariable.java | 4 +-- .../InstanceOfPatternMatch.java | 4 +-- .../LambdaBlockToExpression.java | 8 +++--- .../staticanalysis/LowercasePackage.java | 4 +-- .../staticanalysis/ModifierOrder.java | 12 ++++----- .../NestedEnumsAreNotStatic.java | 4 +-- ...ewStringBuilderBufferWithCharArgument.java | 4 +-- .../NoDoubleBraceInitialization.java | 16 ++++++------ .../NoEmptyCollectionWithRawType.java | 4 +-- .../NoFinalizedLocalVariables.java | 4 +-- ...imitiveWrappersForToStringOrCompareTo.java | 6 ++--- .../NoRedundantJumpStatements.java | 8 +++--- .../ObjectFinalizeCallsSuper.java | 4 +-- ...itiveWrapperClassConstructorToValueOf.java | 4 +-- .../staticanalysis/RedundantFileCreation.java | 4 +-- .../RemoveCallsToObjectFinalize.java | 4 +-- .../staticanalysis/RemoveCallsToSystemGc.java | 4 +-- .../staticanalysis/RemoveExtraSemicolons.java | 10 +++---- .../RemoveJavaDocAuthorTag.java | 4 +-- .../RemoveUnneededAssertion.java | 2 +- .../RemoveUnusedLocalVariables.java | 14 +++++----- .../RemoveUnusedPrivateFields.java | 14 +++++----- .../ReplaceDeprecatedRuntimeExecMethods.java | 4 +-- ...ReplaceOptionalIsPresentWithIfPresent.java | 14 +++++----- .../ReplaceStringBuilderWithString.java | 4 +-- ...avingVarargsWithObjectsRequireNonNull.java | 10 +++---- .../SimplifyConstantIfBranchExecution.java | 26 +++++++++---------- .../SortedSetStreamToLinkedHashSet.java | 4 +-- .../TernaryOperatorsShouldNotBeNested.java | 20 +++++++------- .../staticanalysis/UnnecessaryCatch.java | 4 +-- .../UnnecessaryCloseInTryWithResources.java | 4 +-- .../UnnecessaryPrimitiveAnnotations.java | 10 +++---- .../staticanalysis/UnnecessaryThrows.java | 6 ++--- .../UpperCaseLiteralSuffixes.java | 4 +-- .../staticanalysis/UseDiamondOperator.java | 16 ++++++------ ...UseForEachRemoveInsteadOfSetRemoveAll.java | 4 +-- .../UseJavaStyleArrayDeclarations.java | 8 +++--- .../staticanalysis/UseListSort.java | 4 +-- .../staticanalysis/UseObjectNotifyAll.java | 4 +-- .../staticanalysis/UseStandardCharset.java | 4 +-- .../staticanalysis/UseStringReplace.java | 4 +-- .../WriteOctalValuesAsDecimal.java | 4 +-- .../CompareEnumsWithEqualityOperatorTest.java | 3 ++- .../staticanalysis/MethodNameCasingTest.java | 4 +-- ...veHashCodeCallsFromArrayInstancesTest.java | 9 ++++--- .../SortedSetStreamToLinkedHashSetTest.java | 12 ++++++--- ...TernaryOperatorsShouldNotBeNestedTest.java | 6 +++-- .../staticanalysis/UnnecessaryCatchTest.java | 18 ++++++------- .../UseDiamondOperatorTest.java | 9 ++++--- 61 files changed, 224 insertions(+), 211 deletions(-) diff --git a/src/main/java/org/openrewrite/staticanalysis/AddSerialVersionUidToSerializable.java b/src/main/java/org/openrewrite/staticanalysis/AddSerialVersionUidToSerializable.java index 3fbc17ff7..8eb9e9171 100644 --- a/src/main/java/org/openrewrite/staticanalysis/AddSerialVersionUidToSerializable.java +++ b/src/main/java/org/openrewrite/staticanalysis/AddSerialVersionUidToSerializable.java @@ -57,13 +57,13 @@ public TreeVisitor getVisitor() { final JavaTemplate template = JavaTemplate.builder("private static final long serialVersionUID = 1;").build(); @Override - public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext executionContext) { + public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext ctx) { // Anonymous classes are not of interest return method; } @Override - public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext executionContext) { + public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext ctx) { // Anonymous classes are not of interest return multiVariable; } diff --git a/src/main/java/org/openrewrite/staticanalysis/AtomicPrimitiveEqualsUsesGet.java b/src/main/java/org/openrewrite/staticanalysis/AtomicPrimitiveEqualsUsesGet.java index 50bab7ce3..6a2818425 100644 --- a/src/main/java/org/openrewrite/staticanalysis/AtomicPrimitiveEqualsUsesGet.java +++ b/src/main/java/org/openrewrite/staticanalysis/AtomicPrimitiveEqualsUsesGet.java @@ -58,8 +58,8 @@ public TreeVisitor getVisitor() { private final MethodMatcher aiMethodMatcher = new MethodMatcher("java.lang.Object equals(java.lang.Object)"); @Override - public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { - J.MethodInvocation mi = (J.MethodInvocation) super.visitMethodInvocation(method, executionContext); + public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation mi = (J.MethodInvocation) super.visitMethodInvocation(method, ctx); if (mi.getSelect() != null && isAtomicEqualsType(mi.getSelect().getType()) && aiMethodMatcher.matches(mi) && TypeUtils.isOfType(mi.getSelect().getType(), mi.getArguments().get(0).getType())) { JavaType.FullyQualified fqt = TypeUtils.asFullyQualified(mi.getSelect().getType()); diff --git a/src/main/java/org/openrewrite/staticanalysis/AvoidBoxedBooleanExpressions.java b/src/main/java/org/openrewrite/staticanalysis/AvoidBoxedBooleanExpressions.java index bf6e1896b..56cbc64ac 100644 --- a/src/main/java/org/openrewrite/staticanalysis/AvoidBoxedBooleanExpressions.java +++ b/src/main/java/org/openrewrite/staticanalysis/AvoidBoxedBooleanExpressions.java @@ -67,8 +67,8 @@ public Expression visitExpression(Expression expression, ExecutionContext ctx) { } @Override - public J visitUnary(J.Unary unary, ExecutionContext executionContext) { - J.Unary un = (J.Unary) super.visitUnary(unary, executionContext); + public J visitUnary(J.Unary unary, ExecutionContext ctx) { + J.Unary un = (J.Unary) super.visitUnary(unary, ctx); if (J.Unary.Type.Not == un.getOperator() && TypeUtils.isOfClassType(un.getExpression().getType(), "java.lang.Boolean")) { return JavaTemplate.apply("Boolean.FALSE.equals(#{any(java.lang.Boolean)})", updateCursor(un), un.getCoordinates().replace(), un.getExpression()); diff --git a/src/main/java/org/openrewrite/staticanalysis/BigDecimalRoundingConstantsToEnums.java b/src/main/java/org/openrewrite/staticanalysis/BigDecimalRoundingConstantsToEnums.java index 94d24d1df..7e9d8ceba 100644 --- a/src/main/java/org/openrewrite/staticanalysis/BigDecimalRoundingConstantsToEnums.java +++ b/src/main/java/org/openrewrite/staticanalysis/BigDecimalRoundingConstantsToEnums.java @@ -75,8 +75,8 @@ public TreeVisitor getVisitor() { .imports("java.math.RoundingMode").build(); @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { - J.MethodInvocation m = super.visitMethodInvocation(method, executionContext); + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation m = super.visitMethodInvocation(method, ctx); if (BIG_DECIMAL_DIVIDE.matches(m) && isConvertibleBigDecimalConstant(m.getArguments().get(1))) { String roundingModeEnum = getTemplateText(m.getArguments().get(1)); diff --git a/src/main/java/org/openrewrite/staticanalysis/CatchClauseOnlyRethrows.java b/src/main/java/org/openrewrite/staticanalysis/CatchClauseOnlyRethrows.java index 58968f70f..a12c29cc1 100755 --- a/src/main/java/org/openrewrite/staticanalysis/CatchClauseOnlyRethrows.java +++ b/src/main/java/org/openrewrite/staticanalysis/CatchClauseOnlyRethrows.java @@ -73,8 +73,8 @@ public J.Block visitBlock(J.Block block, ExecutionContext ctx) { } @Override - public J.Try visitTry(J.Try tryable, ExecutionContext executionContext) { - J.Try t = super.visitTry(tryable, executionContext); + public J.Try visitTry(J.Try tryable, ExecutionContext ctx) { + J.Try t = super.visitTry(tryable, ctx); return t.withCatches(ListUtils.map(t.getCatches(), (i, aCatch) -> { if (onlyRethrows(aCatch)) { // if a subsequent catch is a wider exception type and doesn't rethrow, we should diff --git a/src/main/java/org/openrewrite/staticanalysis/CombineSemanticallyEqualCatchBlocks.java b/src/main/java/org/openrewrite/staticanalysis/CombineSemanticallyEqualCatchBlocks.java index a399b5475..3cc88d0e3 100644 --- a/src/main/java/org/openrewrite/staticanalysis/CombineSemanticallyEqualCatchBlocks.java +++ b/src/main/java/org/openrewrite/staticanalysis/CombineSemanticallyEqualCatchBlocks.java @@ -61,8 +61,8 @@ public TreeVisitor getVisitor() { private static class CombineSemanticallyEqualCatchBlocksVisitor extends JavaVisitor { @Override - public J visitTry(J.Try tryable, ExecutionContext executionContext) { - J.Try t = (J.Try) super.visitTry(tryable, executionContext); + public J visitTry(J.Try tryable, ExecutionContext ctx) { + J.Try t = (J.Try) super.visitTry(tryable, ctx); Map> semanticallyEqualCatchesMap = new LinkedHashMap<>(); List catches = t.getCatches(); // Check if the try contains semantically equal catch blocks. @@ -149,24 +149,24 @@ static class RemoveCatches extends JavaVisitor { } @Override - public J visitMultiCatch(J.MultiCatch multiCatch, ExecutionContext executionContext) { + public J visitMultiCatch(J.MultiCatch multiCatch, ExecutionContext ctx) { Cursor parentCursor = getCursor().dropParentUntil(is -> is instanceof J.Try.Catch || is instanceof J.Try); if (removeCatches != null && parentCursor.getValue() instanceof J.Try.Catch) { if (removeCatches.contains((J.Try.Catch) parentCursor.getValue())) { return null; } } - return super.visitMultiCatch(multiCatch, executionContext); + return super.visitMultiCatch(multiCatch, ctx); } @Override - public J visitCatch(J.Try.Catch _catch, ExecutionContext executionContext) { + public J visitCatch(J.Try.Catch _catch, ExecutionContext ctx) { if (removeCatches != null) { if (removeCatches.contains(_catch)) { return null; } } - return super.visitCatch(_catch, executionContext); + return super.visitCatch(_catch, ctx); } } @@ -184,29 +184,29 @@ private static class CombineCatches extends JavaVisitor { } @Override - public J visitMultiCatch(J.MultiCatch multiCatch, ExecutionContext executionContext) { - J.MultiCatch m = (J.MultiCatch) super.visitMultiCatch(multiCatch, executionContext); + public J visitMultiCatch(J.MultiCatch multiCatch, ExecutionContext ctx) { + J.MultiCatch m = (J.MultiCatch) super.visitMultiCatch(multiCatch, ctx); Cursor parentCursor = getCursor().dropParentUntil(is -> is instanceof J.Try.Catch || is instanceof J.Try); if (parentCursor.getValue() instanceof J.Try.Catch) { J.Try.Catch parent = parentCursor.getValue(); if (parent == scope) { List> combinedCatches = combineEquivalentCatches(); - m = maybeAutoFormat(m, m.getPadding().withAlternatives(combinedCatches), executionContext); + m = maybeAutoFormat(m, m.getPadding().withAlternatives(combinedCatches), ctx); } } return m; } @Override - public J visitCatch(J.Try.Catch _catch, ExecutionContext executionContext) { - J.Try.Catch c = (J.Try.Catch) super.visitCatch(_catch, executionContext); + public J visitCatch(J.Try.Catch _catch, ExecutionContext ctx) { + J.Try.Catch c = (J.Try.Catch) super.visitCatch(_catch, ctx); if (c == scope && !isMultiCatch(c)) { if (c.getParameter().getTree().getTypeExpression() != null) { List> combinedCatches = combineEquivalentCatches(); c = maybeAutoFormat(c, c.withParameter(c.getParameter() .withTree(c.getParameter().getTree() .withTypeExpression(new J.MultiCatch(Tree.randomId(), Space.EMPTY, Markers.EMPTY, combinedCatches)))), - executionContext); + ctx); } } return c; diff --git a/src/main/java/org/openrewrite/staticanalysis/ControlFlowIndentation.java b/src/main/java/org/openrewrite/staticanalysis/ControlFlowIndentation.java index 75dea4653..0caa747c7 100755 --- a/src/main/java/org/openrewrite/staticanalysis/ControlFlowIndentation.java +++ b/src/main/java/org/openrewrite/staticanalysis/ControlFlowIndentation.java @@ -76,13 +76,13 @@ public J visit(@Nullable Tree tree, ExecutionContext ctx) { } @Override - public J.Block visitBlock(J.Block block, ExecutionContext executionContext) { - J.Block b = super.visitBlock(block, executionContext); + public J.Block visitBlock(J.Block block, ExecutionContext ctx) { + J.Block b = super.visitBlock(block, ctx); AtomicBoolean foundControlFlowRequiringReformatting = new AtomicBoolean(false); return b.withStatements(ListUtils.map(b.getStatements(), (i, statement) -> { if (foundControlFlowRequiringReformatting.get() || shouldReformat(statement)) { foundControlFlowRequiringReformatting.set(true); - return (Statement) new TabsAndIndentsVisitor<>(tabsAndIndentsStyle).visit(statement, executionContext, getCursor()); + return (Statement) new TabsAndIndentsVisitor<>(tabsAndIndentsStyle).visit(statement, ctx, getCursor()); } return statement; })); diff --git a/src/main/java/org/openrewrite/staticanalysis/ExternalizableHasNoArgsConstructor.java b/src/main/java/org/openrewrite/staticanalysis/ExternalizableHasNoArgsConstructor.java index 88cb7128f..7d122a137 100644 --- a/src/main/java/org/openrewrite/staticanalysis/ExternalizableHasNoArgsConstructor.java +++ b/src/main/java/org/openrewrite/staticanalysis/ExternalizableHasNoArgsConstructor.java @@ -64,8 +64,8 @@ private static class ExternalizableHasNoArgsConstructorVisitor extends JavaIsoVi private static final JavaType externalizableType = JavaType.buildType("java.io.Externalizable"); @Override - public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext executionContext) { - J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, executionContext); + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) { + J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx); if (TypeUtils.isAssignableTo(externalizableType, cd.getType())) { boolean hasFinalUninitializedFieldVar = false; Integer firstMethodDeclarationIndex = null; diff --git a/src/main/java/org/openrewrite/staticanalysis/FinalizeLocalVariables.java b/src/main/java/org/openrewrite/staticanalysis/FinalizeLocalVariables.java index aca7846ba..5ff11339d 100644 --- a/src/main/java/org/openrewrite/staticanalysis/FinalizeLocalVariables.java +++ b/src/main/java/org/openrewrite/staticanalysis/FinalizeLocalVariables.java @@ -45,8 +45,8 @@ public TreeVisitor getVisitor() { return new JavaIsoVisitor() { @Override - public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext p) { - J.VariableDeclarations mv = super.visitVariableDeclarations(multiVariable, p); + public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext ctx) { + J.VariableDeclarations mv = super.visitVariableDeclarations(multiVariable, ctx); // if this already has "final", we don't need to bother going any further; we're done if (mv.hasModifier(J.Modifier.Type.Final)) { @@ -80,7 +80,7 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations m mv = autoFormat( mv.withModifiers( ListUtils.concat(mv.getModifiers(), new J.Modifier(Tree.randomId(), Space.EMPTY, Markers.EMPTY, null, J.Modifier.Type.Final, Collections.emptyList())) - ), p); + ), ctx); } return mv; diff --git a/src/main/java/org/openrewrite/staticanalysis/FinalizeMethodArguments.java b/src/main/java/org/openrewrite/staticanalysis/FinalizeMethodArguments.java index d7191cdb2..af6e78374 100644 --- a/src/main/java/org/openrewrite/staticanalysis/FinalizeMethodArguments.java +++ b/src/main/java/org/openrewrite/staticanalysis/FinalizeMethodArguments.java @@ -54,8 +54,8 @@ public String getDescription() { public TreeVisitor getVisitor() { return new JavaIsoVisitor() { @Override - public MethodDeclaration visitMethodDeclaration(MethodDeclaration methodDeclaration, ExecutionContext executionContext) { - MethodDeclaration declarations = super.visitMethodDeclaration(methodDeclaration, executionContext); + public MethodDeclaration visitMethodDeclaration(MethodDeclaration methodDeclaration, ExecutionContext ctx) { + MethodDeclaration declarations = super.visitMethodDeclaration(methodDeclaration, ctx); if (isWrongKind(methodDeclaration) || isEmpty(declarations.getParameters()) || @@ -92,7 +92,7 @@ private void checkIfAssigned(final AtomicBoolean assigned, final Statement p) { } @Override - public boolean isAcceptable(final SourceFile sourceFile, final ExecutionContext executionContext) { + public boolean isAcceptable(final SourceFile sourceFile, final ExecutionContext ctx) { return sourceFile instanceof JavaSourceFile; } }; diff --git a/src/main/java/org/openrewrite/staticanalysis/FixStringFormatExpressions.java b/src/main/java/org/openrewrite/staticanalysis/FixStringFormatExpressions.java index 289f0c2b8..bafdf1ba6 100644 --- a/src/main/java/org/openrewrite/staticanalysis/FixStringFormatExpressions.java +++ b/src/main/java/org/openrewrite/staticanalysis/FixStringFormatExpressions.java @@ -75,8 +75,8 @@ private static class FixPrintfExpressionsVisitor extends JavaIsoVisitor() { @Nullable @Override - public J visit(@Nullable Tree tree, ExecutionContext executionContext) { - return tree == unary ? null : super.visit(tree, executionContext); + public J visit(@Nullable Tree tree, ExecutionContext ctx) { + return tree == unary ? null : super.visit(tree, ctx); } }.visit(f.getBody(), ctx)); diff --git a/src/main/java/org/openrewrite/staticanalysis/InlineVariable.java b/src/main/java/org/openrewrite/staticanalysis/InlineVariable.java index aca8dbdd2..475e6bf32 100644 --- a/src/main/java/org/openrewrite/staticanalysis/InlineVariable.java +++ b/src/main/java/org/openrewrite/staticanalysis/InlineVariable.java @@ -60,8 +60,8 @@ public Duration getEstimatedEffortPerOccurrence() { public TreeVisitor getVisitor() { return new JavaIsoVisitor() { @Override - public J.Block visitBlock(J.Block block, ExecutionContext executionContext) { - J.Block bl = super.visitBlock(block, executionContext); + public J.Block visitBlock(J.Block block, ExecutionContext ctx) { + J.Block bl = super.visitBlock(block, ctx); List statements = bl.getStatements(); if (statements.size() > 1) { String identReturned = identReturned(statements); diff --git a/src/main/java/org/openrewrite/staticanalysis/InstanceOfPatternMatch.java b/src/main/java/org/openrewrite/staticanalysis/InstanceOfPatternMatch.java index a9fa0dbca..bfcba9c45 100644 --- a/src/main/java/org/openrewrite/staticanalysis/InstanceOfPatternMatch.java +++ b/src/main/java/org/openrewrite/staticanalysis/InstanceOfPatternMatch.java @@ -70,8 +70,8 @@ public TreeVisitor getVisitor() { return Preconditions.check(preconditions, new JavaVisitor() { @Override - public @Nullable J postVisit(J tree, ExecutionContext executionContext) { - J result = super.postVisit(tree, executionContext); + public @Nullable J postVisit(J tree, ExecutionContext ctx) { + J result = super.postVisit(tree, ctx); InstanceOfPatternReplacements original = getCursor().getMessage("flowTypeScope"); if (original != null && !original.isEmpty()) { return UseInstanceOfPatternMatching.refactor(result, original, getCursor().getParentOrThrow()); diff --git a/src/main/java/org/openrewrite/staticanalysis/LambdaBlockToExpression.java b/src/main/java/org/openrewrite/staticanalysis/LambdaBlockToExpression.java index c139e19cf..0f70663c5 100644 --- a/src/main/java/org/openrewrite/staticanalysis/LambdaBlockToExpression.java +++ b/src/main/java/org/openrewrite/staticanalysis/LambdaBlockToExpression.java @@ -42,8 +42,8 @@ public TreeVisitor getVisitor() { return Preconditions.check(new JavaFileChecker<>(), new JavaIsoVisitor() { @Override - public J.Lambda visitLambda(J.Lambda lambda, ExecutionContext executionContext) { - J.Lambda l = super.visitLambda(lambda, executionContext); + public J.Lambda visitLambda(J.Lambda lambda, ExecutionContext ctx) { + J.Lambda l = super.visitLambda(lambda, ctx); if (lambda.getBody() instanceof J.Block) { List statements = ((J.Block) lambda.getBody()).getStatements(); if (statements.size() == 1 && statements.get(0) instanceof J.Return) { @@ -59,11 +59,11 @@ public J.Lambda visitLambda(J.Lambda lambda, ExecutionContext executionContext) } @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { if (hasLambdaArgument(method) && hasMethodOverloading(method)) { return method; } - return super.visitMethodInvocation(method, executionContext); + return super.visitMethodInvocation(method, ctx); } } ); diff --git a/src/main/java/org/openrewrite/staticanalysis/LowercasePackage.java b/src/main/java/org/openrewrite/staticanalysis/LowercasePackage.java index 42b5051fb..326c41f4a 100644 --- a/src/main/java/org/openrewrite/staticanalysis/LowercasePackage.java +++ b/src/main/java/org/openrewrite/staticanalysis/LowercasePackage.java @@ -56,7 +56,7 @@ public Map getInitialValue(ExecutionContext ctx) { public TreeVisitor getScanner(Map acc) { return new JavaIsoVisitor() { @Override - public @Nullable J preVisit(J tree, ExecutionContext executionContext) { + public @Nullable J preVisit(J tree, ExecutionContext ctx) { if (tree instanceof JavaSourceFile) { JavaSourceFile cu = (JavaSourceFile) requireNonNull(tree); J.Package pkg = cu.getPackageDeclaration(); @@ -69,7 +69,7 @@ public TreeVisitor getScanner(Map acc) { } stopAfterPreVisit(); } - return super.preVisit(tree, executionContext); + return super.preVisit(tree, ctx); } }; } diff --git a/src/main/java/org/openrewrite/staticanalysis/ModifierOrder.java b/src/main/java/org/openrewrite/staticanalysis/ModifierOrder.java index 8f37af3a0..441bee9a0 100644 --- a/src/main/java/org/openrewrite/staticanalysis/ModifierOrder.java +++ b/src/main/java/org/openrewrite/staticanalysis/ModifierOrder.java @@ -57,20 +57,20 @@ public Duration getEstimatedEffortPerOccurrence() { public TreeVisitor getVisitor() { return new JavaIsoVisitor() { @Override - public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext executionContext) { - J.ClassDeclaration c = super.visitClassDeclaration(classDecl, executionContext); + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) { + J.ClassDeclaration c = super.visitClassDeclaration(classDecl, ctx); return c.withModifiers(sortModifiers(c.getModifiers())); } @Override - public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext executionContext) { - J.MethodDeclaration m = super.visitMethodDeclaration(method, executionContext); + public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext ctx) { + J.MethodDeclaration m = super.visitMethodDeclaration(method, ctx); return m.withModifiers(sortModifiers(m.getModifiers())); } @Override - public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext executionContext) { - J.VariableDeclarations v = super.visitVariableDeclarations(multiVariable, executionContext); + public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext ctx) { + J.VariableDeclarations v = super.visitVariableDeclarations(multiVariable, ctx); return v.withModifiers(sortModifiers(v.getModifiers())); } }; diff --git a/src/main/java/org/openrewrite/staticanalysis/NestedEnumsAreNotStatic.java b/src/main/java/org/openrewrite/staticanalysis/NestedEnumsAreNotStatic.java index c66a8f3d7..0a187a95c 100644 --- a/src/main/java/org/openrewrite/staticanalysis/NestedEnumsAreNotStatic.java +++ b/src/main/java/org/openrewrite/staticanalysis/NestedEnumsAreNotStatic.java @@ -53,8 +53,8 @@ public Duration getEstimatedEffortPerOccurrence() { public TreeVisitor getVisitor() { return Preconditions.check(new JavaIsoVisitor() { @Override - public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext executionContext) { - J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, executionContext); + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) { + J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx); if (cd.getKind() == J.ClassDeclaration.Kind.Type.Enum && cd.getType() != null && cd.getType().getOwningClass() != null) { cd = SearchResult.found(cd); } diff --git a/src/main/java/org/openrewrite/staticanalysis/NewStringBuilderBufferWithCharArgument.java b/src/main/java/org/openrewrite/staticanalysis/NewStringBuilderBufferWithCharArgument.java index 62bfa57ba..45ca09382 100644 --- a/src/main/java/org/openrewrite/staticanalysis/NewStringBuilderBufferWithCharArgument.java +++ b/src/main/java/org/openrewrite/staticanalysis/NewStringBuilderBufferWithCharArgument.java @@ -57,8 +57,8 @@ public TreeVisitor getVisitor() { private final JavaTemplate toString = JavaTemplate.builder("String.valueOf(#{any()})").build(); @Override - public J.NewClass visitNewClass(J.NewClass newClass, ExecutionContext executionContext) { - J.NewClass nc = super.visitNewClass(newClass, executionContext); + public J.NewClass visitNewClass(J.NewClass newClass, ExecutionContext ctx) { + J.NewClass nc = super.visitNewClass(newClass, ctx); if ((TypeUtils.isOfClassType(nc.getType(), "java.lang.StringBuilder") || TypeUtils.isOfClassType(nc.getType(), "java.lang.StringBuffer"))) { nc.getArguments(); diff --git a/src/main/java/org/openrewrite/staticanalysis/NoDoubleBraceInitialization.java b/src/main/java/org/openrewrite/staticanalysis/NoDoubleBraceInitialization.java index 4a24e7ff8..fa6c1c301 100644 --- a/src/main/java/org/openrewrite/staticanalysis/NoDoubleBraceInitialization.java +++ b/src/main/java/org/openrewrite/staticanalysis/NoDoubleBraceInitialization.java @@ -86,8 +86,8 @@ && getCursor().getParent(3) != null) { } @Override - public J.NewClass visitNewClass(J.NewClass newClass, ExecutionContext executionContext) { - J.NewClass nc = super.visitNewClass(newClass, executionContext); + public J.NewClass visitNewClass(J.NewClass newClass, ExecutionContext ctx) { + J.NewClass nc = super.visitNewClass(newClass, ctx); updateCursor(nc); if (isSupportedDoubleBraceInitialization(newClass)) { Cursor parentBlockCursor = getCursor().dropParentUntil(J.Block.class::isInstance); @@ -123,12 +123,12 @@ public J.NewClass visitNewClass(J.NewClass newClass, ExecutionContext executionC String newInitializer = " new " + fq.getClassName() + "<>();"; JavaTemplate template = JavaTemplate.builder(newInitializer).imports(fq.getFullyQualifiedName()).build(); nc = template.apply(getCursor(), nc.getCoordinates().replace()); - initStatements = addSelectToInitStatements(initStatements, var.getName(), executionContext); + initStatements = addSelectToInitStatements(initStatements, var.getName(), ctx); initStatements.add(0, new J.Assignment(UUID.randomUUID(), Space.EMPTY, Markers.EMPTY, var.getName().withId(UUID.randomUUID()), JLeftPadded.build(nc), fq)); parentBlockCursor.computeMessageIfAbsent("INIT_STATEMENTS", v -> new HashMap>()).put(varDeclsCursor.getValue(), initStatements); } } else if (parentBlockCursor.getParent().getValue() instanceof J.MethodDeclaration) { - initStatements = addSelectToInitStatements(initStatements, var.getName(), executionContext); + initStatements = addSelectToInitStatements(initStatements, var.getName(), ctx); Cursor varDeclsCursor = getCursor().dropParentUntil(J.VariableDeclarations.class::isInstance); parentBlockCursor.computeMessageIfAbsent("METHOD_DECL_STATEMENTS", v -> new HashMap>()).put(varDeclsCursor.getValue(), initStatements); nc = nc.withBody(null); @@ -156,8 +156,8 @@ public AddSelectVisitor(J.Identifier identifier) { } @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { - J.MethodInvocation mi = super.visitMethodInvocation(method, executionContext); + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation mi = super.visitMethodInvocation(method, ctx); if (mi.getMethodType() != null && identifier.getFieldType() != null && mi.getSelect() == null || (mi.getSelect() instanceof J.Identifier && "this".equals(((J.Identifier) mi.getSelect()).getSimpleName()))) { if (identifier.getFieldType() == null) { @@ -180,8 +180,8 @@ public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, Execu } @Override - public J.VariableDeclarations.NamedVariable visitVariable(J.VariableDeclarations.NamedVariable variable, ExecutionContext executionContext) { - J.VariableDeclarations.NamedVariable var = super.visitVariable(variable, executionContext); + public J.VariableDeclarations.NamedVariable visitVariable(J.VariableDeclarations.NamedVariable variable, ExecutionContext ctx) { + J.VariableDeclarations.NamedVariable var = super.visitVariable(variable, ctx); if (getCursor().pollMessage("DROP_INITIALIZER") != null) { var = var.withInitializer(null); } diff --git a/src/main/java/org/openrewrite/staticanalysis/NoEmptyCollectionWithRawType.java b/src/main/java/org/openrewrite/staticanalysis/NoEmptyCollectionWithRawType.java index 972fb5e3c..0f5d4252c 100644 --- a/src/main/java/org/openrewrite/staticanalysis/NoEmptyCollectionWithRawType.java +++ b/src/main/java/org/openrewrite/staticanalysis/NoEmptyCollectionWithRawType.java @@ -66,13 +66,13 @@ public TreeVisitor getVisitor() { } @Override - public J visitImport(J.Import anImport, ExecutionContext executionContext) { + public J visitImport(J.Import anImport, ExecutionContext ctx) { J.Identifier name = anImport.getQualid().getName(); if (anImport.isStatic() && name.getSimpleName().startsWith("EMPTY_") && TypeUtils.isOfClassType(anImport.getQualid().getTarget().getType(), "java.util.Collections")) { return anImport.withQualid(anImport.getQualid().withName(name.withSimpleName(updateFields.get(name.getSimpleName())))); } - return super.visitImport(anImport, executionContext); + return super.visitImport(anImport, ctx); } @Override diff --git a/src/main/java/org/openrewrite/staticanalysis/NoFinalizedLocalVariables.java b/src/main/java/org/openrewrite/staticanalysis/NoFinalizedLocalVariables.java index 66e2222c7..353b04aef 100644 --- a/src/main/java/org/openrewrite/staticanalysis/NoFinalizedLocalVariables.java +++ b/src/main/java/org/openrewrite/staticanalysis/NoFinalizedLocalVariables.java @@ -39,8 +39,8 @@ public String getDescription() { public TreeVisitor getVisitor() { return new JavaIsoVisitor() { @Override - public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext p) { - J.VariableDeclarations mv = super.visitVariableDeclarations(multiVariable, p); + public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext ctx) { + J.VariableDeclarations mv = super.visitVariableDeclarations(multiVariable, ctx); // if this doesn't have "final", we don't need to bother going any further; we're done if (!mv.hasModifier(J.Modifier.Type.Final)) { diff --git a/src/main/java/org/openrewrite/staticanalysis/NoPrimitiveWrappersForToStringOrCompareTo.java b/src/main/java/org/openrewrite/staticanalysis/NoPrimitiveWrappersForToStringOrCompareTo.java index c27675cd3..8ace2f205 100644 --- a/src/main/java/org/openrewrite/staticanalysis/NoPrimitiveWrappersForToStringOrCompareTo.java +++ b/src/main/java/org/openrewrite/staticanalysis/NoPrimitiveWrappersForToStringOrCompareTo.java @@ -81,8 +81,8 @@ private static class NoPrimitiveWrapperVisitor extends JavaIsoVisitor getVisitor() { return new JavaIsoVisitor() { @Override - public J.If visitIf(J.If iff, ExecutionContext executionContext) { - J.If i = super.visitIf(iff, executionContext); + public J.If visitIf(J.If iff, ExecutionContext ctx) { + J.If i = super.visitIf(iff, ctx); boolean thenIsOnlyContinue = i.getThenPart() instanceof J.Continue; if (i.getThenPart() instanceof J.Block) { @@ -92,8 +92,8 @@ public J.If visitIf(J.If iff, ExecutionContext executionContext) { } @Override - public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext executionContext) { - J.MethodDeclaration m = super.visitMethodDeclaration(method, executionContext); + public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext ctx) { + J.MethodDeclaration m = super.visitMethodDeclaration(method, ctx); JavaType.Method methodType = m.getMethodType(); if (m.getBody() != null && methodType != null && JavaType.Primitive.Void.equals(methodType.getReturnType())) { return m.withBody(m.getBody().withStatements(ListUtils.mapLast(m.getBody().getStatements(), s -> s instanceof J.Return ? null : s))); diff --git a/src/main/java/org/openrewrite/staticanalysis/ObjectFinalizeCallsSuper.java b/src/main/java/org/openrewrite/staticanalysis/ObjectFinalizeCallsSuper.java index 04319ec4e..9e922c97f 100644 --- a/src/main/java/org/openrewrite/staticanalysis/ObjectFinalizeCallsSuper.java +++ b/src/main/java/org/openrewrite/staticanalysis/ObjectFinalizeCallsSuper.java @@ -54,8 +54,8 @@ public Duration getEstimatedEffortPerOccurrence() { public TreeVisitor getVisitor() { return Preconditions.check(new DeclaresMethod<>(FINALIZE_METHOD_MATCHER), new JavaIsoVisitor() { @Override - public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext executionContext) { - J.MethodDeclaration md = super.visitMethodDeclaration(method, executionContext); + public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext ctx) { + J.MethodDeclaration md = super.visitMethodDeclaration(method, ctx); if (FINALIZE_METHOD_MATCHER.matches(md.getMethodType()) && !hasSuperFinalizeMethodInvocation(md)) { //noinspection ConstantConditions md = JavaTemplate.builder("super.finalize()") diff --git a/src/main/java/org/openrewrite/staticanalysis/PrimitiveWrapperClassConstructorToValueOf.java b/src/main/java/org/openrewrite/staticanalysis/PrimitiveWrapperClassConstructorToValueOf.java index 4f18e74b8..3fc20580d 100644 --- a/src/main/java/org/openrewrite/staticanalysis/PrimitiveWrapperClassConstructorToValueOf.java +++ b/src/main/java/org/openrewrite/staticanalysis/PrimitiveWrapperClassConstructorToValueOf.java @@ -67,8 +67,8 @@ public TreeVisitor getVisitor() { ); return Preconditions.check(condition, new JavaVisitor() { @Override - public J visitNewClass(J.NewClass newClass, ExecutionContext executionContext) { - J.NewClass nc = (J.NewClass) super.visitNewClass(newClass, executionContext); + public J visitNewClass(J.NewClass newClass, ExecutionContext ctx) { + J.NewClass nc = (J.NewClass) super.visitNewClass(newClass, ctx); JavaType.FullyQualified type = TypeUtils.asFullyQualified(nc.getType()); if (type != null && nc.getArguments().size() == 1) { Expression arg = nc.getArguments().get(0); diff --git a/src/main/java/org/openrewrite/staticanalysis/RedundantFileCreation.java b/src/main/java/org/openrewrite/staticanalysis/RedundantFileCreation.java index 84f60f226..1f8db0ba7 100644 --- a/src/main/java/org/openrewrite/staticanalysis/RedundantFileCreation.java +++ b/src/main/java/org/openrewrite/staticanalysis/RedundantFileCreation.java @@ -40,8 +40,8 @@ public String getDescription() { public TreeVisitor getVisitor() { return Preconditions.check(new UsesType<>("java.io.FileInputStream", true), new JavaIsoVisitor() { @Override - public J.NewClass visitNewClass(J.NewClass newClass, ExecutionContext executionContext) { - J.NewClass n = super.visitNewClass(newClass, executionContext); + public J.NewClass visitNewClass(J.NewClass newClass, ExecutionContext ctx) { + J.NewClass n = super.visitNewClass(newClass, ctx); if (n.getClazz() != null && TypeUtils.isOfClassType(n.getClazz().getType(), "java.io.FileInputStream")) { n = n.withArguments(ListUtils.map(n.getArguments(), arg -> { diff --git a/src/main/java/org/openrewrite/staticanalysis/RemoveCallsToObjectFinalize.java b/src/main/java/org/openrewrite/staticanalysis/RemoveCallsToObjectFinalize.java index b6138a5a0..d8d893995 100644 --- a/src/main/java/org/openrewrite/staticanalysis/RemoveCallsToObjectFinalize.java +++ b/src/main/java/org/openrewrite/staticanalysis/RemoveCallsToObjectFinalize.java @@ -56,8 +56,8 @@ public Duration getEstimatedEffortPerOccurrence() { public TreeVisitor getVisitor() { return Preconditions.check(new UsesMethod<>(OBJECT_FINALIZE), new JavaIsoVisitor() { @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext context) { - J.MethodInvocation invocation = super.visitMethodInvocation(method, context); + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation invocation = super.visitMethodInvocation(method, ctx); if (invocation.getMethodType() != null && "finalize".equals(invocation.getMethodType().getName()) && (invocation.getMethodType().getDeclaringType().getSupertype() != null && Object.class.getName().equals(invocation.getMethodType().getDeclaringType().getSupertype().getFullyQualifiedName()))) { diff --git a/src/main/java/org/openrewrite/staticanalysis/RemoveCallsToSystemGc.java b/src/main/java/org/openrewrite/staticanalysis/RemoveCallsToSystemGc.java index 6cf702584..f8b1c10af 100644 --- a/src/main/java/org/openrewrite/staticanalysis/RemoveCallsToSystemGc.java +++ b/src/main/java/org/openrewrite/staticanalysis/RemoveCallsToSystemGc.java @@ -57,8 +57,8 @@ public Duration getEstimatedEffortPerOccurrence() { public TreeVisitor getVisitor() { return Preconditions.check(Preconditions.or(new UsesMethod<>(SYSTEM_GC), new UsesMethod<>(RUNTIME_GC)), new JavaIsoVisitor() { @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext context) { - J.MethodInvocation invocation = super.visitMethodInvocation(method, context); + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation invocation = super.visitMethodInvocation(method, ctx); if (SYSTEM_GC.matches(invocation) || RUNTIME_GC.matches(invocation)) { doAfterVisit(new EmptyBlock().getVisitor()); //noinspection DataFlowIssue diff --git a/src/main/java/org/openrewrite/staticanalysis/RemoveExtraSemicolons.java b/src/main/java/org/openrewrite/staticanalysis/RemoveExtraSemicolons.java index 313d3a84c..a17e42eb4 100644 --- a/src/main/java/org/openrewrite/staticanalysis/RemoveExtraSemicolons.java +++ b/src/main/java/org/openrewrite/staticanalysis/RemoveExtraSemicolons.java @@ -55,7 +55,7 @@ public TreeVisitor getVisitor() { return new JavaIsoVisitor() { @Override - public J.Block visitBlock(final J.Block block, final ExecutionContext executionContext) { + public J.Block visitBlock(final J.Block block, final ExecutionContext ctx) { final Iterator iterator = block.getStatements().iterator(); final List result = new ArrayList<>(); while (iterator.hasNext()) { @@ -75,11 +75,11 @@ public J.Block visitBlock(final J.Block block, final ExecutionContext executionC result.add(statement); } } - return super.visitBlock(block.withStatements(result), executionContext); + return super.visitBlock(block.withStatements(result), ctx); } @Override - public J.Try.Resource visitTryResource(J.Try.Resource tr, ExecutionContext executionContext) { + public J.Try.Resource visitTryResource(J.Try.Resource tr, ExecutionContext ctx) { J.Try _try = getCursor().dropParentUntil(J.Try.class::isInstance).getValue(); if (_try.getResources().isEmpty() || _try.getResources().get(_try.getResources().size() - 1) != tr || @@ -90,8 +90,8 @@ public J.Try.Resource visitTryResource(J.Try.Resource tr, ExecutionContext execu } @Override - public J.EnumValueSet visitEnumValueSet(J.EnumValueSet enums, ExecutionContext executionContext) { - J.EnumValueSet e = super.visitEnumValueSet(enums, executionContext); + public J.EnumValueSet visitEnumValueSet(J.EnumValueSet enums, ExecutionContext ctx) { + J.EnumValueSet e = super.visitEnumValueSet(enums, ctx); if (getCursor().firstEnclosing(J.Block.class).getStatements().size() == 1) { e = e.withTerminatedWithSemicolon(false); } diff --git a/src/main/java/org/openrewrite/staticanalysis/RemoveJavaDocAuthorTag.java b/src/main/java/org/openrewrite/staticanalysis/RemoveJavaDocAuthorTag.java index f80b336ab..c0abfbd66 100644 --- a/src/main/java/org/openrewrite/staticanalysis/RemoveJavaDocAuthorTag.java +++ b/src/main/java/org/openrewrite/staticanalysis/RemoveJavaDocAuthorTag.java @@ -50,8 +50,8 @@ public TreeVisitor getVisitor() { protected JavadocVisitor getJavadocVisitor() { return new JavadocVisitor(this) { @Override - public Javadoc visitDocComment(Javadoc.DocComment javadoc, ExecutionContext executionContext) { - Javadoc.DocComment dc = (Javadoc.DocComment) super.visitDocComment(javadoc, executionContext); + public Javadoc visitDocComment(Javadoc.DocComment javadoc, ExecutionContext ctx) { + Javadoc.DocComment dc = (Javadoc.DocComment) super.visitDocComment(javadoc, ctx); List newBody = new ArrayList<>(); boolean isChanged = false; boolean removeNextLineBreak = false; diff --git a/src/main/java/org/openrewrite/staticanalysis/RemoveUnneededAssertion.java b/src/main/java/org/openrewrite/staticanalysis/RemoveUnneededAssertion.java index 1e42b3f42..1530a77cd 100644 --- a/src/main/java/org/openrewrite/staticanalysis/RemoveUnneededAssertion.java +++ b/src/main/java/org/openrewrite/staticanalysis/RemoveUnneededAssertion.java @@ -66,7 +66,7 @@ public TreeVisitor getVisitor() { new UsesMethod<>(JUNIT_ASSERT_MESSAGE_FALSE_MATCHER), new JavaIsoVisitor() { @Override - public J.Assert visitAssert(J.Assert _assert, ExecutionContext executionContext) { + public J.Assert visitAssert(J.Assert _assert, ExecutionContext ctx) { if (J.Literal.isLiteralValue(_assert.getCondition(), true)) { return SearchResult.found(_assert); } diff --git a/src/main/java/org/openrewrite/staticanalysis/RemoveUnusedLocalVariables.java b/src/main/java/org/openrewrite/staticanalysis/RemoveUnusedLocalVariables.java index a8f4d9c3e..6e2089d5e 100644 --- a/src/main/java/org/openrewrite/staticanalysis/RemoveUnusedLocalVariables.java +++ b/src/main/java/org/openrewrite/staticanalysis/RemoveUnusedLocalVariables.java @@ -142,12 +142,12 @@ public J.VariableDeclarations.NamedVariable visitVariable(J.VariableDeclarations } @Override - public Statement visitStatement(Statement statement, ExecutionContext executionContext) { + public Statement visitStatement(Statement statement, ExecutionContext ctx) { List comments = getCursor().pollNearestMessage("COMMENTS_KEY"); if (comments != null) { statement = statement.withComments(ListUtils.concatAll(statement.getComments(), comments)); } - return super.visitStatement(statement, executionContext); + return super.visitStatement(statement, ctx); } @Override @@ -208,17 +208,17 @@ private static class PruneAssignmentExpression extends JavaIsoVisitor J.ControlParentheses visitControlParentheses(J.ControlParentheses c, ExecutionContext executionContext) { + public J.ControlParentheses visitControlParentheses(J.ControlParentheses c, ExecutionContext ctx) { //noinspection unchecked c = (J.ControlParentheses) new AssignmentToLiteral(assignment) - .visitNonNull(c, executionContext, getCursor().getParentOrThrow()); + .visitNonNull(c, ctx, getCursor().getParentOrThrow()); return c; } @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation m, ExecutionContext executionContext) { + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation m, ExecutionContext ctx) { AssignmentToLiteral atl = new AssignmentToLiteral(assignment); - m = m.withArguments(ListUtils.map(m.getArguments(), it -> (Expression) atl.visitNonNull(it, executionContext, getCursor().getParentOrThrow()))); + m = m.withArguments(ListUtils.map(m.getArguments(), it -> (Expression) atl.visitNonNull(it, ctx, getCursor().getParentOrThrow()))); return m; } } @@ -229,7 +229,7 @@ private static class AssignmentToLiteral extends JavaVisitor { J.Assignment assignment; @Override - public J visitAssignment(J.Assignment a, ExecutionContext executionContext) { + public J visitAssignment(J.Assignment a, ExecutionContext ctx) { if (assignment.isScope(a)) { return a.getAssignment().withPrefix(a.getPrefix()); } diff --git a/src/main/java/org/openrewrite/staticanalysis/RemoveUnusedPrivateFields.java b/src/main/java/org/openrewrite/staticanalysis/RemoveUnusedPrivateFields.java index 7d4c0f657..93e27f137 100644 --- a/src/main/java/org/openrewrite/staticanalysis/RemoveUnusedPrivateFields.java +++ b/src/main/java/org/openrewrite/staticanalysis/RemoveUnusedPrivateFields.java @@ -64,8 +64,8 @@ class CheckField { } @Override - public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext executionContext) { - J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, executionContext); + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) { + J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx); List checkFields = new ArrayList<>(); // Do not remove fields with `serialVersionUID` name. @@ -117,7 +117,7 @@ public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, Ex } // Maybe remove next statement comment if variable declarations is removed if (declarationDeleted.get()) { - cd = (J.ClassDeclaration) new MaybeRemoveComment(checkField.nextStatement, cd).visitNonNull(cd, executionContext); + cd = (J.ClassDeclaration) new MaybeRemoveComment(checkField.nextStatement, cd).visitNonNull(cd, ctx); } } } @@ -216,7 +216,7 @@ public MaybeRemoveComment(@Nullable Statement statement, J.ClassDeclaration clas } @Override - public J visitStatement(Statement s, ExecutionContext executionContext) { + public J visitStatement(Statement s, ExecutionContext ctx) { if (s == statement) { Space prefix = s.getPrefix(); // If we have at least one comment and there is no newline @@ -230,11 +230,11 @@ public J visitStatement(Statement s, ExecutionContext executionContext) { } } - return super.visitStatement(s, executionContext); + return super.visitStatement(s, ctx); } @Override - public J visitClassDeclaration(J.ClassDeclaration c, ExecutionContext executionContext) { + public J visitClassDeclaration(J.ClassDeclaration c, ExecutionContext ctx) { // We also need to remove comments attached to end of classDeclaration if it's the last statement if (statement == null && c == classDeclaration) { Space end = c.getBody().getEnd(); @@ -246,7 +246,7 @@ public J visitClassDeclaration(J.ClassDeclaration c, ExecutionContext executionC )); } } - return super.visitClassDeclaration(c, executionContext); + return super.visitClassDeclaration(c, ctx); } } diff --git a/src/main/java/org/openrewrite/staticanalysis/ReplaceDeprecatedRuntimeExecMethods.java b/src/main/java/org/openrewrite/staticanalysis/ReplaceDeprecatedRuntimeExecMethods.java index 22b8c6251..fb3e293db 100644 --- a/src/main/java/org/openrewrite/staticanalysis/ReplaceDeprecatedRuntimeExecMethods.java +++ b/src/main/java/org/openrewrite/staticanalysis/ReplaceDeprecatedRuntimeExecMethods.java @@ -53,8 +53,8 @@ public Duration getEstimatedEffortPerOccurrence() { public TreeVisitor getVisitor() { return Preconditions.check(new UsesJavaVersion<>(18), new JavaIsoVisitor() { @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { - J.MethodInvocation m = super.visitMethodInvocation(method, executionContext); + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation m = super.visitMethodInvocation(method, ctx); if (RUNTIME_EXEC_CMD.matches(m) || RUNTIME_EXEC_CMD_ENVP.matches(m) || RUNTIME_EXEC_CMD_ENVP_FILE.matches(m)) { Expression command = m.getArguments().get(0); diff --git a/src/main/java/org/openrewrite/staticanalysis/ReplaceOptionalIsPresentWithIfPresent.java b/src/main/java/org/openrewrite/staticanalysis/ReplaceOptionalIsPresentWithIfPresent.java index 77e4d83ee..116129410 100644 --- a/src/main/java/org/openrewrite/staticanalysis/ReplaceOptionalIsPresentWithIfPresent.java +++ b/src/main/java/org/openrewrite/staticanalysis/ReplaceOptionalIsPresentWithIfPresent.java @@ -61,9 +61,9 @@ public J visitCompilationUnit(J.CompilationUnit cu, ExecutionContext ctx) { } @Override - public J visitIf(J.If _if, ExecutionContext context) { + public J visitIf(J.If _if, ExecutionContext ctx) { J.If before = _if; - J.If after = (J.If) super.visitIf(_if, context); + J.If after = (J.If) super.visitIf(_if, ctx); boolean updated = after != before; _if = after; if (!(_if.getIfCondition().getTree() instanceof J.MethodInvocation) || @@ -118,7 +118,7 @@ public J visitIf(J.If _if, ExecutionContext context) { ((J.VariableDeclarations) ((J.Lambda) ((J.MethodInvocation) ifPresentMi).getArguments().get(0)) .getParameters().getParameters().get(0)).getVariables().get(0).getName(); lambdaAccessibleVariables.add(lambdaParameterIdentifier); - return ReplaceMethodCallWithVariableVisitor.replace(ifPresentMi, context, lambdaParameterIdentifier, + return ReplaceMethodCallWithVariableVisitor.replace(ifPresentMi, ctx, lambdaParameterIdentifier, optionalVariable); } @@ -228,13 +228,13 @@ public static class ReplaceMethodCallWithVariableVisitor extends JavaVisitor getVisitor() { return Preconditions.check(Preconditions.and(new UsesMethod<>(STRING_BUILDER_APPEND), new UsesMethod<>(STRING_BUILDER_TO_STRING)), new JavaVisitor() { @Override - public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { - J.MethodInvocation m = (J.MethodInvocation) super.visitMethodInvocation(method, executionContext); + public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation m = (J.MethodInvocation) super.visitMethodInvocation(method, ctx); if (STRING_BUILDER_TO_STRING.matches(method)) { List methodCallsChain = new ArrayList<>(); diff --git a/src/main/java/org/openrewrite/staticanalysis/ReplaceValidateNotNullHavingVarargsWithObjectsRequireNonNull.java b/src/main/java/org/openrewrite/staticanalysis/ReplaceValidateNotNullHavingVarargsWithObjectsRequireNonNull.java index 2aa35f169..f0513ca5a 100644 --- a/src/main/java/org/openrewrite/staticanalysis/ReplaceValidateNotNullHavingVarargsWithObjectsRequireNonNull.java +++ b/src/main/java/org/openrewrite/staticanalysis/ReplaceValidateNotNullHavingVarargsWithObjectsRequireNonNull.java @@ -49,8 +49,8 @@ public String getDescription() { public TreeVisitor getVisitor() { return Preconditions.check(new UsesMethod<>(VALIDATE_NOTNULL), new JavaVisitor() { @Override - public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext p) { - J.MethodInvocation mi = (J.MethodInvocation) super.visitMethodInvocation(method, p); + public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation mi = (J.MethodInvocation) super.visitMethodInvocation(method, ctx); if (!VALIDATE_NOTNULL.matches(mi)) { return mi; } @@ -72,7 +72,7 @@ public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext p) { if (arguments.size() == 2) { return maybeAutoFormat(mi, mi.withArguments( - ListUtils.map(mi.getArguments(), (a, b) -> b.withPrefix(arguments.get(a).getPrefix()))), p); + ListUtils.map(mi.getArguments(), (a, b) -> b.withPrefix(arguments.get(a).getPrefix()))), ctx); } // Retain comments and whitespace around lambda arguments @@ -84,8 +84,8 @@ public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext p) { stringFormatMi = stringFormatMi.withArguments( ListUtils.map(stringFormatMi.getArguments(), (a, b) -> b.withPrefix(arguments.get(a).getPrefix()))); - lambda = maybeAutoFormat(lambda, lambda.withBody(stringFormatMi), p); - return maybeAutoFormat(mi, mi.withArguments(Stream.of(arg0, lambda).collect(Collectors.toList())), p); + lambda = maybeAutoFormat(lambda, lambda.withBody(stringFormatMi), ctx); + return maybeAutoFormat(mi, mi.withArguments(Stream.of(arg0, lambda).collect(Collectors.toList())), ctx); } }); } diff --git a/src/main/java/org/openrewrite/staticanalysis/SimplifyConstantIfBranchExecution.java b/src/main/java/org/openrewrite/staticanalysis/SimplifyConstantIfBranchExecution.java index 8e61a25f7..704a6201f 100644 --- a/src/main/java/org/openrewrite/staticanalysis/SimplifyConstantIfBranchExecution.java +++ b/src/main/java/org/openrewrite/staticanalysis/SimplifyConstantIfBranchExecution.java @@ -52,43 +52,43 @@ public TreeVisitor getVisitor() { private static class SimplifyConstantIfBranchExecutionVisitor extends JavaVisitor { @Override - public J visitBlock(J.Block block, ExecutionContext executionContext) { - J.Block bl = (J.Block) super.visitBlock(block, executionContext); + public J visitBlock(J.Block block, ExecutionContext ctx) { + J.Block bl = (J.Block) super.visitBlock(block, ctx); if (bl != block) { bl = (J.Block) new RemoveUnneededBlock.RemoveUnneededBlockStatementVisitor() - .visitNonNull(bl, executionContext, getCursor().getParentOrThrow()); + .visitNonNull(bl, ctx, getCursor().getParentOrThrow()); EmptyBlockStyle style = ((SourceFile) getCursor().firstEnclosingOrThrow(JavaSourceFile.class)) .getStyle(EmptyBlockStyle.class); if (style == null) { style = Checkstyle.emptyBlock(); } bl = (J.Block) new EmptyBlockVisitor<>(style) - .visitNonNull(bl, executionContext, getCursor().getParentOrThrow()); + .visitNonNull(bl, ctx, getCursor().getParentOrThrow()); } return bl; } @SuppressWarnings("unchecked") private E cleanupBooleanExpression( - E expression, ExecutionContext context + E expression, ExecutionContext ctx ) { E ex1 = (E) new UnnecessaryParenthesesVisitor() - .visitNonNull(expression, context, getCursor().getParentOrThrow()); + .visitNonNull(expression, ctx, getCursor().getParentOrThrow()); ex1 = (E) new SimplifyBooleanExpressionVisitor() - .visitNonNull(ex1, context, getCursor().getParentTreeCursor()); + .visitNonNull(ex1, ctx, getCursor().getParentTreeCursor()); if (expression == ex1 || isLiteralFalse(ex1) || isLiteralTrue(ex1)) { return ex1; } // Run recursively until no further changes are needed - return cleanupBooleanExpression(ex1, context); + return cleanupBooleanExpression(ex1, ctx); } @Override - public J visitIf(J.If if_, ExecutionContext context) { - J.If if__ = (J.If) super.visitIf(if_, context); + public J visitIf(J.If if_, ExecutionContext ctx) { + J.If if__ = (J.If) super.visitIf(if_, ctx); - J.ControlParentheses cp = cleanupBooleanExpression(if__.getIfCondition(), context); + J.ControlParentheses cp = cleanupBooleanExpression(if__.getIfCondition(), ctx); if__ = if__.withIfCondition(cp); // The compile-time constant value of the if condition control parentheses. @@ -113,7 +113,7 @@ public J visitIf(J.If if_, ExecutionContext context) { return maybeAutoFormat( if__, s, - context + ctx ); } else { // False branch @@ -125,7 +125,7 @@ public J visitIf(J.If if_, ExecutionContext context) { return maybeAutoFormat( if__, s, - context + ctx ); } /* diff --git a/src/main/java/org/openrewrite/staticanalysis/SortedSetStreamToLinkedHashSet.java b/src/main/java/org/openrewrite/staticanalysis/SortedSetStreamToLinkedHashSet.java index c62a837c9..7339e09f3 100644 --- a/src/main/java/org/openrewrite/staticanalysis/SortedSetStreamToLinkedHashSet.java +++ b/src/main/java/org/openrewrite/staticanalysis/SortedSetStreamToLinkedHashSet.java @@ -53,8 +53,8 @@ public TreeVisitor getVisitor() { .build(); @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { - J.MethodInvocation mi = super.visitMethodInvocation(method, executionContext); + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation mi = super.visitMethodInvocation(method, ctx); if (STREAM_COLLECT_METHOD_MATCHER.matches(mi) && STREAM_SORTED_METHOD_MATCHER.matches(mi.getSelect()) && COLLECTORS_TO_SET_METHOD_MATCHER.matches(mi.getArguments().get(0))) { diff --git a/src/main/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNested.java b/src/main/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNested.java index 8ffefb526..6ad941013 100644 --- a/src/main/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNested.java +++ b/src/main/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNested.java @@ -70,7 +70,7 @@ public TreeVisitor getVisitor() { @Override public J.CompilationUnit visitCompilationUnit( final J.CompilationUnit cu, - final ExecutionContext executionContext + final ExecutionContext ctx ) { if (cu.getMarkers() .findFirst(JavaVersion.class) @@ -87,23 +87,23 @@ public J.CompilationUnit visitCompilationUnit( private static class UseIfVisitor extends JavaVisitor { @Override - public J visitLambda(final J.Lambda lambda, final ExecutionContext executionContext) { + public J visitLambda(final J.Lambda lambda, final ExecutionContext ctx) { J result = rewriteNestedTernary(lambda); if (result == lambda) { - return super.visitLambda(lambda, executionContext); + return super.visitLambda(lambda, ctx); } doAfterVisit(new RemoveUnneededBlock().getVisitor()); - return autoFormat(lambda.withBody(result.withPrefix(Space.SINGLE_SPACE)), executionContext); + return autoFormat(lambda.withBody(result.withPrefix(Space.SINGLE_SPACE)), ctx); } @Override - public J visitReturn(final J.Return retrn, final ExecutionContext executionContext) { + public J visitReturn(final J.Return retrn, final ExecutionContext ctx) { J result = rewriteNestedTernary(retrn); if (result == retrn) { - return super.visitReturn(retrn, executionContext); + return super.visitReturn(retrn, ctx); } doAfterVisit(new RemoveUnneededBlock().getVisitor()); - return autoFormat(result, executionContext); + return autoFormat(result, ctx); } private Statement rewriteNestedTernary(final Statement parent) { @@ -166,15 +166,15 @@ private static Optional findTernary(Statement parent) { static class UseSwitchExpressionVisitor extends JavaVisitor { @Override - public J visitTernary(final J.Ternary ternary, final ExecutionContext executionContext) { + public J visitTernary(final J.Ternary ternary, final ExecutionContext ctx) { return findConditionIdentifier(ternary).map(switchVar -> { List nestList = findNestedTernaries(ternary, switchVar); if (nestList.size() < 2) { return null; } - return autoFormat(toSwitch(switchVar, nestList), executionContext); + return autoFormat(toSwitch(switchVar, nestList), ctx); }).map(J.class::cast) - .orElseGet(() -> super.visitTernary(ternary, executionContext)); + .orElseGet(() -> super.visitTernary(ternary, ctx)); } private List findNestedTernaries(final J.Ternary ternary, final J.Identifier switchVar) { diff --git a/src/main/java/org/openrewrite/staticanalysis/UnnecessaryCatch.java b/src/main/java/org/openrewrite/staticanalysis/UnnecessaryCatch.java index 0c9fc2ba2..85351ae61 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UnnecessaryCatch.java +++ b/src/main/java/org/openrewrite/staticanalysis/UnnecessaryCatch.java @@ -73,8 +73,8 @@ public J.Block visitBlock(J.Block block, ExecutionContext ctx) { } @Override - public J.Try visitTry(J.Try tryable, ExecutionContext executionContext) { - J.Try t = super.visitTry(tryable, executionContext); + public J.Try visitTry(J.Try tryable, ExecutionContext ctx) { + J.Try t = super.visitTry(tryable, ctx); List thrownExceptions = new ArrayList<>(); AtomicBoolean missingTypeInformation = new AtomicBoolean(false); diff --git a/src/main/java/org/openrewrite/staticanalysis/UnnecessaryCloseInTryWithResources.java b/src/main/java/org/openrewrite/staticanalysis/UnnecessaryCloseInTryWithResources.java index 9378b0c1e..23fb22d7a 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UnnecessaryCloseInTryWithResources.java +++ b/src/main/java/org/openrewrite/staticanalysis/UnnecessaryCloseInTryWithResources.java @@ -57,8 +57,8 @@ private static class UnnecessaryAutoCloseableVisitor extends JavaIsoVisitor getVisitor() { Preconditions.or(new UsesType<>("javax.annotation.CheckForNull", false), new UsesType<>("javax.annotation.Nullable", false)), new JavaIsoVisitor() { @Override - public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext executionContext) { - J.MethodDeclaration md = super.visitMethodDeclaration(method, executionContext); + public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext ctx) { + J.MethodDeclaration md = super.visitMethodDeclaration(method, ctx); if (md.getReturnTypeExpression() != null && !(md.getReturnTypeExpression() instanceof J.ArrayType) && md.getReturnTypeExpression().getType() instanceof JavaType.Primitive) { - md = maybeAutoFormat(md, md.withLeadingAnnotations(filterAnnotations(md.getLeadingAnnotations())), executionContext); + md = maybeAutoFormat(md, md.withLeadingAnnotations(filterAnnotations(md.getLeadingAnnotations())), ctx); } return md; } @Override - public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext executionContext) { - J.VariableDeclarations varDecls = super.visitVariableDeclarations(multiVariable, executionContext); + public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext ctx) { + J.VariableDeclarations varDecls = super.visitVariableDeclarations(multiVariable, ctx); if (varDecls.getType() instanceof JavaType.Primitive && varDecls.getVariables().stream().noneMatch(nv -> nv.getType() instanceof JavaType.Array)) { varDecls = varDecls.withLeadingAnnotations(filterAnnotations(varDecls.getLeadingAnnotations())); } diff --git a/src/main/java/org/openrewrite/staticanalysis/UnnecessaryThrows.java b/src/main/java/org/openrewrite/staticanalysis/UnnecessaryThrows.java index eb600b7a4..8795536c8 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UnnecessaryThrows.java +++ b/src/main/java/org/openrewrite/staticanalysis/UnnecessaryThrows.java @@ -77,7 +77,7 @@ public J visit(@Nullable Tree tree, ExecutionContext ctx) { } @Override - public J.Try.Resource visitTryResource(J.Try.Resource tryResource, ExecutionContext executionContext) { + public J.Try.Resource visitTryResource(J.Try.Resource tryResource, ExecutionContext ctx) { TypedTree resource = tryResource.getVariableDeclarations(); JavaType.FullyQualified resourceType = TypeUtils.asFullyQualified(resource.getType()); @@ -89,11 +89,11 @@ public J.Try.Resource visitTryResource(J.Try.Resource tryResource, ExecutionCont } } - return super.visitTryResource(tryResource, executionContext); + return super.visitTryResource(tryResource, ctx); } @Override - public J.Throw visitThrow(J.Throw thrown, ExecutionContext executionContext) { + public J.Throw visitThrow(J.Throw thrown, ExecutionContext ctx) { JavaType.FullyQualified type = TypeUtils.asFullyQualified(thrown.getException().getType()); if (type != null) { unusedThrows.removeIf(t -> TypeUtils.isAssignableTo(t, type)); diff --git a/src/main/java/org/openrewrite/staticanalysis/UpperCaseLiteralSuffixes.java b/src/main/java/org/openrewrite/staticanalysis/UpperCaseLiteralSuffixes.java index 2a406c53c..edad53f25 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UpperCaseLiteralSuffixes.java +++ b/src/main/java/org/openrewrite/staticanalysis/UpperCaseLiteralSuffixes.java @@ -62,8 +62,8 @@ public TreeVisitor getVisitor() { new UsesType<>("java.lang.Float", false) ), new JavaIsoVisitor() { @Override - public J.VariableDeclarations.NamedVariable visitVariable(J.VariableDeclarations.NamedVariable variable, ExecutionContext executionContext) { - J.VariableDeclarations.NamedVariable nv = super.visitVariable(variable, executionContext); + public J.VariableDeclarations.NamedVariable visitVariable(J.VariableDeclarations.NamedVariable variable, ExecutionContext ctx) { + J.VariableDeclarations.NamedVariable nv = super.visitVariable(variable, ctx); if (nv.getInitializer() instanceof J.Literal && nv.getInitializer().getType() != null) { J.Literal initializer = (J.Literal) nv.getInitializer(); if (initializer.getType() == JavaType.Primitive.Double diff --git a/src/main/java/org/openrewrite/staticanalysis/UseDiamondOperator.java b/src/main/java/org/openrewrite/staticanalysis/UseDiamondOperator.java index 9134e7e76..e84c6137e 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UseDiamondOperator.java +++ b/src/main/java/org/openrewrite/staticanalysis/UseDiamondOperator.java @@ -69,8 +69,8 @@ public J.CompilationUnit visitCompilationUnit(J.CompilationUnit cu, ExecutionCon } @Override - public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext executionContext) { - J.VariableDeclarations varDecls = super.visitVariableDeclarations(multiVariable, executionContext); + public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations multiVariable, ExecutionContext ctx) { + J.VariableDeclarations varDecls = super.visitVariableDeclarations(multiVariable, ctx); final TypedTree varDeclsTypeExpression = varDecls.getTypeExpression(); if (varDecls.getVariables().size() == 1 && varDecls.getVariables().get(0).getInitializer() != null && varDecls.getTypeExpression() instanceof J.ParameterizedType) { @@ -85,8 +85,8 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations m } @Override - public J.Assignment visitAssignment(J.Assignment assignment, ExecutionContext executionContext) { - J.Assignment asgn = super.visitAssignment(assignment, executionContext); + public J.Assignment visitAssignment(J.Assignment assignment, ExecutionContext ctx) { + J.Assignment asgn = super.visitAssignment(assignment, ctx); if (asgn.getAssignment() instanceof J.NewClass) { JavaType.Parameterized assignmentType = TypeUtils.asParameterized(asgn.getType()); J.NewClass nc = (J.NewClass) asgn.getAssignment(); @@ -98,12 +98,12 @@ public J.Assignment visitAssignment(J.Assignment assignment, ExecutionContext ex } @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { if (isAParameter()) { return method; } - J.MethodInvocation mi = super.visitMethodInvocation(method, executionContext); + J.MethodInvocation mi = super.visitMethodInvocation(method, ctx); JavaType.Method methodType = mi.getMethodType(); if (methodType != null && @@ -180,8 +180,8 @@ private JavaType getMethodParamType(JavaType.Method methodType, int paramIndex) } @Override - public J.Return visitReturn(J.Return _return, ExecutionContext executionContext) { - J.Return return_ = super.visitReturn(_return, executionContext); + public J.Return visitReturn(J.Return _return, ExecutionContext ctx) { + J.Return return_ = super.visitReturn(_return, ctx); J.NewClass nc = return_.getExpression() instanceof J.NewClass ? (J.NewClass) return_.getExpression() : null; if (nc != null && (java9 || nc.getBody() == null) && nc.getClazz() instanceof J.ParameterizedType) { J parentBlock = getCursor().dropParentUntil(v -> v instanceof J.MethodDeclaration || v instanceof J.Lambda).getValue(); diff --git a/src/main/java/org/openrewrite/staticanalysis/UseForEachRemoveInsteadOfSetRemoveAll.java b/src/main/java/org/openrewrite/staticanalysis/UseForEachRemoveInsteadOfSetRemoveAll.java index 23d36ce23..ed53a92ff 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UseForEachRemoveInsteadOfSetRemoveAll.java +++ b/src/main/java/org/openrewrite/staticanalysis/UseForEachRemoveInsteadOfSetRemoveAll.java @@ -40,8 +40,8 @@ public TreeVisitor getVisitor() { MethodMatcher removeAll = new MethodMatcher("java.util.Set removeAll(java.util.Collection)"); return Preconditions.check(new UsesMethod<>(removeAll), new JavaIsoVisitor() { @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { - J.MethodInvocation mi = super.visitMethodInvocation(method, executionContext); + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation mi = super.visitMethodInvocation(method, ctx); if (removeAll.matches(mi) && !returnValueIsUsed()) { mi = JavaTemplate.builder("#{any(java.util.Collection)}.forEach(#{any(java.util.Set)}::remove)") .build() diff --git a/src/main/java/org/openrewrite/staticanalysis/UseJavaStyleArrayDeclarations.java b/src/main/java/org/openrewrite/staticanalysis/UseJavaStyleArrayDeclarations.java index 13319b74c..e34ed4e03 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UseJavaStyleArrayDeclarations.java +++ b/src/main/java/org/openrewrite/staticanalysis/UseJavaStyleArrayDeclarations.java @@ -56,8 +56,8 @@ public Set getTags() { public TreeVisitor getVisitor() { return new JavaIsoVisitor() { @Override - public VariableDeclarations visitVariableDeclarations(VariableDeclarations multiVariable, ExecutionContext executionContext) { - VariableDeclarations varDecls = super.visitVariableDeclarations(multiVariable, executionContext); + public VariableDeclarations visitVariableDeclarations(VariableDeclarations multiVariable, ExecutionContext ctx) { + VariableDeclarations varDecls = super.visitVariableDeclarations(multiVariable, ctx); List> dimensions = getCursor().pollMessage("VAR_DIMENSIONS"); if (dimensions != null) { varDecls = varDecls.withDimensionsBeforeName(dimensions); @@ -66,8 +66,8 @@ public VariableDeclarations visitVariableDeclarations(VariableDeclarations multi } @Override - public VariableDeclarations.NamedVariable visitVariable(VariableDeclarations.NamedVariable variable, ExecutionContext executionContext) { - VariableDeclarations.NamedVariable nv = super.visitVariable(variable, executionContext); + public VariableDeclarations.NamedVariable visitVariable(VariableDeclarations.NamedVariable variable, ExecutionContext ctx) { + VariableDeclarations.NamedVariable nv = super.visitVariable(variable, ctx); if (!nv.getDimensionsAfterName().isEmpty()) { getCursor().dropParentUntil(VariableDeclarations.class::isInstance).putMessage("VAR_DIMENSIONS", nv.getDimensionsAfterName()); nv = nv.withDimensionsAfterName(ListUtils.map(nv.getDimensionsAfterName(), dim -> null)); diff --git a/src/main/java/org/openrewrite/staticanalysis/UseListSort.java b/src/main/java/org/openrewrite/staticanalysis/UseListSort.java index 9c02df9b2..d0ce878d6 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UseListSort.java +++ b/src/main/java/org/openrewrite/staticanalysis/UseListSort.java @@ -42,8 +42,8 @@ public TreeVisitor getVisitor() { final MethodMatcher collectionsSort = new MethodMatcher("java.util.Collections sort(..)"); return Preconditions.check(new UsesMethod<>(collectionsSort), new JavaIsoVisitor() { @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { - J.MethodInvocation mi = super.visitMethodInvocation(method, executionContext); + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation mi = super.visitMethodInvocation(method, ctx); if (collectionsSort.matches(mi)) { updateCursor(mi); maybeRemoveImport("java.util.Collections"); diff --git a/src/main/java/org/openrewrite/staticanalysis/UseObjectNotifyAll.java b/src/main/java/org/openrewrite/staticanalysis/UseObjectNotifyAll.java index 3eaad04f5..92c6f3fd3 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UseObjectNotifyAll.java +++ b/src/main/java/org/openrewrite/staticanalysis/UseObjectNotifyAll.java @@ -56,8 +56,8 @@ public TreeVisitor getVisitor() { MethodMatcher objectNotify = new MethodMatcher("java.lang.Object notify()"); return Preconditions.check(new UsesMethod<>(objectNotify), new JavaIsoVisitor() { @Override - public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext context) { - J.MethodInvocation m = super.visitMethodInvocation(method, context); + public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation m = super.visitMethodInvocation(method, ctx); return objectNotify.matches(method) ? m .withName(m.getName().withSimpleName("notifyAll")) : m; } diff --git a/src/main/java/org/openrewrite/staticanalysis/UseStandardCharset.java b/src/main/java/org/openrewrite/staticanalysis/UseStandardCharset.java index 82662cd4e..934b8fc5d 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UseStandardCharset.java +++ b/src/main/java/org/openrewrite/staticanalysis/UseStandardCharset.java @@ -55,8 +55,8 @@ public TreeVisitor getVisitor() { final MethodMatcher CHARSET_FOR_NAME = new MethodMatcher("java.nio.charset.Charset forName(java.lang.String)"); @Override - public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext executionContext) { - J.MethodInvocation m = (J.MethodInvocation) super.visitMethodInvocation(method, executionContext); + public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) { + J.MethodInvocation m = (J.MethodInvocation) super.visitMethodInvocation(method, ctx); if (CHARSET_FOR_NAME.matches(m)) { Expression charsetName = m.getArguments().get(0); if (!(charsetName instanceof J.Literal)) { diff --git a/src/main/java/org/openrewrite/staticanalysis/UseStringReplace.java b/src/main/java/org/openrewrite/staticanalysis/UseStringReplace.java index 914790884..35b3d6919 100644 --- a/src/main/java/org/openrewrite/staticanalysis/UseStringReplace.java +++ b/src/main/java/org/openrewrite/staticanalysis/UseStringReplace.java @@ -78,8 +78,8 @@ private static class UseStringReplaceVisitor extends JavaVisitor getVisitor() { return new JavaVisitor() { @Override - public J visitLiteral(J.Literal literal, ExecutionContext executionContext) { + public J visitLiteral(J.Literal literal, ExecutionContext ctx) { String src = literal.getValueSource(); if (src != null && src.startsWith("0")) { if (src.length() >= 2 && @@ -65,7 +65,7 @@ public J visitLiteral(J.Literal literal, ExecutionContext executionContext) { return literal.withValueSource(literal.getValue().toString()); } } - return super.visitLiteral(literal, executionContext); + return super.visitLiteral(literal, ctx); } }; } diff --git a/src/test/java/org/openrewrite/staticanalysis/CompareEnumsWithEqualityOperatorTest.java b/src/test/java/org/openrewrite/staticanalysis/CompareEnumsWithEqualityOperatorTest.java index bb7cdb329..56da8dd14 100644 --- a/src/test/java/org/openrewrite/staticanalysis/CompareEnumsWithEqualityOperatorTest.java +++ b/src/test/java/org/openrewrite/staticanalysis/CompareEnumsWithEqualityOperatorTest.java @@ -205,7 +205,8 @@ void m(Object parameterValue, Type partType) { void noSelect() { rewriteRun( //language=java - java(""" + java( + """ package a; public enum A { FOO, BAR, BUZ; diff --git a/src/test/java/org/openrewrite/staticanalysis/MethodNameCasingTest.java b/src/test/java/org/openrewrite/staticanalysis/MethodNameCasingTest.java index 94514ce20..d9153bc56 100644 --- a/src/test/java/org/openrewrite/staticanalysis/MethodNameCasingTest.java +++ b/src/test/java/org/openrewrite/staticanalysis/MethodNameCasingTest.java @@ -450,8 +450,8 @@ void doesNotRenameMethodInvocationsWhenTheMethodDeclarationsClassTypeIsNull() { .recipes( toRecipe(() -> new JavaIsoVisitor<>() { @Override - public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext executionContext) { - return super.visitClassDeclaration(classDecl, executionContext).withType(null); + public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) { + return super.visitClassDeclaration(classDecl, ctx).withType(null); } }), new MethodNameCasing(true, false) diff --git a/src/test/java/org/openrewrite/staticanalysis/RemoveHashCodeCallsFromArrayInstancesTest.java b/src/test/java/org/openrewrite/staticanalysis/RemoveHashCodeCallsFromArrayInstancesTest.java index 4bce2fe12..9daf23dc1 100644 --- a/src/test/java/org/openrewrite/staticanalysis/RemoveHashCodeCallsFromArrayInstancesTest.java +++ b/src/test/java/org/openrewrite/staticanalysis/RemoveHashCodeCallsFromArrayInstancesTest.java @@ -36,7 +36,8 @@ public void defaults(RecipeSpec spec) { void replaceHashCodeCalls() { //language=java rewriteRun( - java(""" + java( + """ class SomeClass { public static void main(String[] args) { int argHash = args.hashCode(); @@ -58,7 +59,8 @@ public static void main(String[] args) { void selectIsAMethod() { //language=java rewriteRun( - java(""" + java( + """ class SomeClass { void foo() { int hashCode = getArr().hashCode(); @@ -88,7 +90,8 @@ public int[] getArr() { void onlyRunOnArrayInstances() { //language=java rewriteRun( - java(""" + java( + """ class SomeClass { void foo() { String name = "bill"; diff --git a/src/test/java/org/openrewrite/staticanalysis/SortedSetStreamToLinkedHashSetTest.java b/src/test/java/org/openrewrite/staticanalysis/SortedSetStreamToLinkedHashSetTest.java index 444846432..538ca44b2 100644 --- a/src/test/java/org/openrewrite/staticanalysis/SortedSetStreamToLinkedHashSetTest.java +++ b/src/test/java/org/openrewrite/staticanalysis/SortedSetStreamToLinkedHashSetTest.java @@ -33,7 +33,8 @@ public void defaults(RecipeSpec spec) { void changeSortedSetStreamToLinkedHashSet() { rewriteRun( //language=java - java(""" + java( + """ import java.util.Set; import java.util.stream.Collectors; @@ -59,7 +60,8 @@ void method(Set set) { void changeSortedSetStreamToLinkedHashSetStaticImport() { rewriteRun( //language=java - java(""" + java( + """ import java.util.Set; import static java.util.stream.Collectors.toSet; @@ -85,7 +87,8 @@ void method(Set set) { void ignoreCollectToLinkedHashSet() { rewriteRun( //language=java - java(""" + java( + """ import java.util.Set; import java.util.LinkedHashSet; import java.util.stream.Collectors; @@ -102,7 +105,8 @@ void method(Set set) { void ignoreCollectToList() { rewriteRun( //language=java - java(""" + java( + """ import java.util.List; import java.util.Set; import java.util.stream.Collectors; diff --git a/src/test/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNestedTest.java b/src/test/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNestedTest.java index 4192c9732..f7bbfa4f3 100644 --- a/src/test/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNestedTest.java +++ b/src/test/java/org/openrewrite/staticanalysis/TernaryOperatorsShouldNotBeNestedTest.java @@ -524,7 +524,8 @@ public String determineSomething(String a, String b) { void doReplaceNestedOrTernaryContainingMethodCall() { //language=java rewriteRun( - java(""" + java( + """ class M{ static String a(){return "a";} static String b(){return "b";} @@ -1090,7 +1091,8 @@ public String determineSomething(String a, String b) { void doReplaceNestedOrTernaryContainingMethodCall() { //language=java rewriteRun( - java(""" + java( + """ class M{ static String a(){return "a";} static String b(){return "b";} diff --git a/src/test/java/org/openrewrite/staticanalysis/UnnecessaryCatchTest.java b/src/test/java/org/openrewrite/staticanalysis/UnnecessaryCatchTest.java index 59e855d60..35651fa37 100644 --- a/src/test/java/org/openrewrite/staticanalysis/UnnecessaryCatchTest.java +++ b/src/test/java/org/openrewrite/staticanalysis/UnnecessaryCatchTest.java @@ -146,15 +146,15 @@ void doNotRemoveJavaLangException() { //language=java java( """ - class Scratch { - void method() { - try { - throw new RuntimeException(); - } catch (Exception e) { - System.out.println("an exception!"); - } - } - } + class Scratch { + void method() { + try { + throw new RuntimeException(); + } catch (Exception e) { + System.out.println("an exception!"); + } + } + } """ ) ); diff --git a/src/test/java/org/openrewrite/staticanalysis/UseDiamondOperatorTest.java b/src/test/java/org/openrewrite/staticanalysis/UseDiamondOperatorTest.java index d29d5840e..047b4e558 100644 --- a/src/test/java/org/openrewrite/staticanalysis/UseDiamondOperatorTest.java +++ b/src/test/java/org/openrewrite/staticanalysis/UseDiamondOperatorTest.java @@ -493,7 +493,8 @@ void doNotChangeInferredGenericTypes() { rewriteRun( spec -> spec.allSources(s -> s.markers(javaVersion(9))), //language=java - java(""" + java( + """ @FunctionalInterface public interface IVisitor { void visit(T object, R ret); @@ -501,7 +502,8 @@ public interface IVisitor { """ ), //language=java - java(""" + java( + """ class Test { public R method(IVisitor visitor) { return null; @@ -525,7 +527,8 @@ void doNotChangeAnnotatedTypeParameters() { .allSources(s -> s.markers(javaVersion(9))) .parser(JavaParser.fromJavaVersion().classpath("annotations-24.1.0")), //language=java - java(""" + java( + """ import org.jetbrains.annotations.Nullable; import java.util.ArrayList; import java.util.List;