Add PowerMockWhiteboxToJavaReflection recipe (#944)

* Add PowerMockWhiteboxToJavaReflection recipe

Replace `org.powermock.reflect.Whitebox` calls with plain Java
reflection as part of the ReplacePowerMockito recipe chain.

Handles setInternalState, getInternalState, and invokeMethod by
expanding each call into getDeclaredField/getDeclaredMethod +
setAccessible + get/set/invoke. Uses VariableNameUtils to avoid
name collisions when multiple Whitebox calls target the same field.

* Regenerate recipes.csv to include PowerMockWhiteboxToJavaReflection

* Add powermock-reflect-1.6.5 classpath JAR for type resolution

* Regenerate classpath type table to include powermock-reflect

The classpath.tsv.gz type table is what CI uses for type resolution
in tests. The previously committed JAR is unnecessary when the type
table includes the artifact.

* Address review feedback on PowerMockWhiteboxToJavaReflection

- Inline the named WhiteboxVisitor into an anonymous class
- Use immediate return for maybeAutoFormat
- Remove unnecessary powermock-reflect-1 classpath from integration test

* Fix template type attribution by using #{any(java.lang.Object)}

Untyped #{any()} placeholders caused the template parser to infer the
argument's actual type (e.g. MyService), which is not on the template
parser's classpath. This broke type resolution for the entire method
chain (.getClass(), .getDeclaredField(), .setAccessible(), etc.).

Using #{any(java.lang.Object)} ensures the substitution always resolves
against a JDK type, fixing type attribution. Also inlines the JAVA_PARSER
field and removes the now-unnecessary methodInvocations(false) from the
unit test.

---------

Co-authored-by: Tim te Beek <tim@moderne.io>

Author: bmuschko

build.gradle.kts

@@ -39,6 +39,7 @@ recipeDependencies {
     parserClasspath("org.powermock:powermock-api-mockito:1.6.5")
     parserClasspath("org.powermock:powermock-api-support:1.6.5")
     parserClasspath("org.powermock:powermock-core:1.6.5")
+    parserClasspath("org.powermock:powermock-reflect:1.6.5")
     parserClasspath("org.springframework:spring-test:6.1.+")
     parserClasspath("org.testcontainers:testcontainers:1.20.6")
     parserClasspath("org.testcontainers:junit-jupiter:1.20.6")

src/main/java/org/openrewrite/java/testing/mockito/PowerMockWhiteboxToJavaReflection.java

@@ -0,0 +1,290 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.testing.mockito;
+
+import lombok.Getter;
+import org.jspecify.annotations.Nullable;
+import org.openrewrite.*;
+import org.openrewrite.internal.ListUtils;
+import org.openrewrite.java.*;
+import org.openrewrite.java.search.UsesType;
+import org.openrewrite.java.tree.*;
+import org.openrewrite.marker.Markers;
+
+import java.util.List;
+
+import static java.util.Collections.emptyList;
+import static org.openrewrite.Tree.randomId;
+import static org.openrewrite.java.VariableNameUtils.GenerationStrategy.INCREMENT_NUMBER;
+import static org.openrewrite.java.VariableNameUtils.generateVariableName;
+
+public class PowerMockWhiteboxToJavaReflection extends Recipe {
+
+    private static final String WHITEBOX_FQN = "org.powermock.reflect.Whitebox";
+    private static final MethodMatcher SET_INTERNAL_STATE =
+            new MethodMatcher("org.powermock.reflect.Whitebox setInternalState(java.lang.Object, java.lang.String, java.lang.Object)");
+    private static final MethodMatcher GET_INTERNAL_STATE =
+            new MethodMatcher("org.powermock.reflect.Whitebox getInternalState(java.lang.Object, java.lang.String)");
+    private static final MethodMatcher INVOKE_METHOD =
+            new MethodMatcher("org.powermock.reflect.Whitebox invokeMethod(java.lang.Object, java.lang.String, ..)");
+
+    @Getter
+    final String displayName = "Replace PowerMock `Whitebox` with Java reflection";
+
+    @Getter
+    final String description = "Replace `org.powermock.reflect.Whitebox` calls " +
+            "(`setInternalState`, `getInternalState`, `invokeMethod`) with plain Java reflection using " +
+            "`java.lang.reflect.Field` and `java.lang.reflect.Method`.";
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return Preconditions.check(
+                new UsesType<>(WHITEBOX_FQN, false),
+                new JavaIsoVisitor<ExecutionContext>() {
+
+        private static final String WHITEBOX_REPLACED = "whiteboxReplaced";
+        private static final String NEEDS_FIELD_IMPORT = "needsFieldImport";
+        private static final String NEEDS_METHOD_IMPORT = "needsMethodImport";
+
+        @Override
+        public J.MethodDeclaration visitMethodDeclaration(J.MethodDeclaration method, ExecutionContext ctx) {
+            J.MethodDeclaration md = super.visitMethodDeclaration(method, ctx);
+            if (getCursor().getMessage(WHITEBOX_REPLACED, false)) {
+                md = addThrowsExceptionIfAbsent(md);
+                maybeRemoveImport(WHITEBOX_FQN);
+                if (getCursor().getMessage(NEEDS_FIELD_IMPORT, false)) {
+                    maybeAddImport("java.lang.reflect.Field", false);
+                }
+                if (getCursor().getMessage(NEEDS_METHOD_IMPORT, false)) {
+                    maybeAddImport("java.lang.reflect.Method", false);
+                }
+                return maybeAutoFormat(method, md, ctx);
+            }
+            return md;
+        }
+
+        @Override
+        public J.Block visitBlock(J.Block block, ExecutionContext ctx) {
+            J.Block b = super.visitBlock(block, ctx);
+
+            List<Statement> statements = b.getStatements();
+            // Process in reverse so that coordinate positions remain valid after each replacement
+            for (int i = statements.size() - 1; i >= 0; i--) {
+                Statement stmt = statements.get(i);
+                J.MethodInvocation mi = extractWhiteboxInvocation(stmt);
+                if (mi == null) {
+                    continue;
+                }
+                Cursor blockCursor = new Cursor(getCursor().getParentOrThrow(), b);
+                String template = buildReplacementTemplate(stmt, mi, blockCursor);
+                if (template != null) {
+                    Object[] templateArgs = buildTemplateArgs(mi);
+                    b = JavaTemplate.builder(template)
+                            .contextSensitive()
+                            .javaParser(JavaParser.fromJavaVersion())
+                            .imports("java.lang.reflect.Field", "java.lang.reflect.Method")
+                            .build()
+                            .apply(
+                                    new Cursor(getCursor().getParentOrThrow(), b),
+                                    stmt.getCoordinates().replace(),
+                                    templateArgs
+                            );
+                    getCursor().putMessageOnFirstEnclosing(J.MethodDeclaration.class, WHITEBOX_REPLACED, true);
+                    if (SET_INTERNAL_STATE.matches(mi) || GET_INTERNAL_STATE.matches(mi)) {
+                        getCursor().putMessageOnFirstEnclosing(J.MethodDeclaration.class, NEEDS_FIELD_IMPORT, true);
+                    }
+                    if (INVOKE_METHOD.matches(mi)) {
+                        getCursor().putMessageOnFirstEnclosing(J.MethodDeclaration.class, NEEDS_METHOD_IMPORT, true);
+                    }
+                    // Re-read statements list since the block has been rebuilt
+                    statements = b.getStatements();
+                }
+            }
+
+            return b;
+        }
+
+        private @Nullable String buildReplacementTemplate(Statement statement, J.MethodInvocation mi, Cursor scope) {
+            List<Expression> args = mi.getArguments();
+
+            if (SET_INTERNAL_STATE.matches(mi) && args.size() == 3) {
+                return buildSetInternalStateTemplate(args, scope);
+            }
+            if (GET_INTERNAL_STATE.matches(mi) && args.size() == 2) {
+                return buildGetInternalStateTemplate(args, statement, scope);
+            }
+            if (INVOKE_METHOD.matches(mi) && args.size() >= 2) {
+                return buildInvokeMethodTemplate(args, statement, scope);
+            }
+            return null;
+        }
+
+        private Object[] buildTemplateArgs(J.MethodInvocation mi) {
+            List<Expression> args = mi.getArguments();
+
+            if (SET_INTERNAL_STATE.matches(mi) && args.size() == 3) {
+                // target, fieldName, target, value
+                return new Object[]{args.get(0), args.get(1), args.get(0), args.get(2)};
+            }
+            if (GET_INTERNAL_STATE.matches(mi) && args.size() == 2) {
+                // target, fieldName, target
+                return new Object[]{args.get(0), args.get(1), args.get(0)};
+            }
+            if (INVOKE_METHOD.matches(mi) && args.size() >= 2) {
+                return buildInvokeMethodArgs(args);
+            }
+            return new Object[0];
+        }
+
+        private @Nullable String buildSetInternalStateTemplate(List<Expression> args, Cursor scope) {
+            String fieldName = extractStringLiteral(args.get(1));
+            if (fieldName == null) {
+                return null;
+            }
+            String varName = generateVariableName(fieldName + "Field", scope, INCREMENT_NUMBER);
+            return "Field " + varName + " = #{any(java.lang.Object)}.getClass().getDeclaredField(#{any(java.lang.String)});\n" +
+                    varName + ".setAccessible(true);\n" +
+                    varName + ".set(#{any(java.lang.Object)}, #{any(java.lang.Object)});";
+        }
+
+        private @Nullable String buildGetInternalStateTemplate(List<Expression> args, Statement statement, Cursor scope) {
+            String fieldName = extractStringLiteral(args.get(1));
+            if (fieldName == null) {
+                return null;
+            }
+            String varName = generateVariableName(fieldName + "Field", scope, INCREMENT_NUMBER);
+            String prefix = "Field " + varName + " = #{any(java.lang.Object)}.getClass().getDeclaredField(#{any(java.lang.String)});\n" +
+                    varName + ".setAccessible(true);\n";
+
+            if (statement instanceof J.VariableDeclarations) {
+                J.VariableDeclarations varDecls = (J.VariableDeclarations) statement;
+                String assignToVar = varDecls.getVariables().get(0).getSimpleName();
+                String castType = getCastType(varDecls.getType());
+                if (castType != null && !"Object".equals(castType) && !"java.lang.Object".equals(castType)) {
+                    return prefix + castType + " " + assignToVar + " = (" + castType + ") " + varName + ".get(#{any(java.lang.Object)});";
+                }
+                return prefix + "Object " + assignToVar + " = " + varName + ".get(#{any(java.lang.Object)});";
+            }
+            return prefix + varName + ".get(#{any(java.lang.Object)});";
+        }
+
+        private @Nullable String buildInvokeMethodTemplate(List<Expression> args, Statement statement, Cursor scope) {
+            String methodName = extractStringLiteral(args.get(1));
+            if (methodName == null) {
+                return null;
+            }
+            String varName = generateVariableName(methodName + "Method", scope, INCREMENT_NUMBER);
+
+            // getDeclaredMethod line
+            StringBuilder sb = new StringBuilder();
+            sb.append("Method ").append(varName).append(" = #{any(java.lang.Object)}.getClass().getDeclaredMethod(#{any(java.lang.String)}");
+            for (int i = 2; i < args.size(); i++) {
+                sb.append(", #{any(java.lang.Object)}.getClass()");
+            }
+            sb.append(");\n");
+
+            // setAccessible line
+            sb.append(varName).append(".setAccessible(true);\n");
+
+            // invoke line
+            if (statement instanceof J.VariableDeclarations) {
+                J.VariableDeclarations varDecls = (J.VariableDeclarations) statement;
+                String assignToVar = varDecls.getVariables().get(0).getSimpleName();
+                String castType = getCastType(varDecls.getType());
+                if (castType != null && !"Object".equals(castType) && !"java.lang.Object".equals(castType)) {
+                    sb.append(castType).append(" ").append(assignToVar).append(" = (").append(castType).append(") ");
+                } else {
+                    sb.append("Object ").append(assignToVar).append(" = ");
+                }
+            }
+            sb.append(varName).append(".invoke(#{any(java.lang.Object)}");
+            for (int i = 2; i < args.size(); i++) {
+                sb.append(", #{any(java.lang.Object)}");
+            }
+            sb.append(");");
+
+            return sb.toString();
+        }
+
+        private Object[] buildInvokeMethodArgs(List<Expression> args) {
+            int extraArgs = args.size() - 2;
+            Object[] result = new Object[2 + extraArgs + 1 + extraArgs];
+            int idx = 0;
+            result[idx++] = args.get(0); // target for getDeclaredMethod
+            result[idx++] = args.get(1); // methodName
+            for (int i = 2; i < args.size(); i++) {
+                result[idx++] = args.get(i); // arg.getClass() for getDeclaredMethod
+            }
+            result[idx++] = args.get(0); // target for invoke
+            for (int i = 2; i < args.size(); i++) {
+                result[idx++] = args.get(i); // arg for invoke
+            }
+            return result;
+        }
+
+        private J.@Nullable MethodInvocation extractWhiteboxInvocation(Statement statement) {
+            if (statement instanceof J.MethodInvocation) {
+                J.MethodInvocation mi = (J.MethodInvocation) statement;
+                if (SET_INTERNAL_STATE.matches(mi) || GET_INTERNAL_STATE.matches(mi) || INVOKE_METHOD.matches(mi)) {
+                    return mi;
+                }
+            }
+            if (statement instanceof J.VariableDeclarations) {
+                J.VariableDeclarations varDecls = (J.VariableDeclarations) statement;
+                if (varDecls.getVariables().size() == 1) {
+                    Expression init = varDecls.getVariables().get(0).getInitializer();
+                    if (init instanceof J.MethodInvocation) {
+                        J.MethodInvocation mi = (J.MethodInvocation) init;
+                        if (GET_INTERNAL_STATE.matches(mi) || INVOKE_METHOD.matches(mi)) {
+                            return mi;
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+
+        private @Nullable String extractStringLiteral(Expression expr) {
+            if (expr instanceof J.Literal && ((J.Literal) expr).getValue() instanceof String) {
+                return (String) ((J.Literal) expr).getValue();
+            }
+            return null;
+        }
+
+        private @Nullable String getCastType(@Nullable JavaType type) {
+            if (type instanceof JavaType.FullyQualified) {
+                return ((JavaType.FullyQualified) type).getClassName();
+            }
+            if (type instanceof JavaType.Primitive) {
+                return ((JavaType.Primitive) type).getKeyword();
+            }
+            return null;
+        }
+
+        private J.MethodDeclaration addThrowsExceptionIfAbsent(J.MethodDeclaration md) {
+            if (md.getThrows() != null && md.getThrows().stream()
+                    .anyMatch(j -> TypeUtils.isOfClassType(j.getType(), "java.lang.Exception") ||
+                            TypeUtils.isOfClassType(j.getType(), "java.lang.Throwable"))) {
+                return md;
+            }
+            JavaType.Class exceptionType = JavaType.ShallowClass.build("java.lang.Exception");
+            return md.withThrows(ListUtils.concat(md.getThrows(),
+                    new J.Identifier(randomId(), Space.SINGLE_SPACE, Markers.EMPTY, emptyList(),
+                            exceptionType.getClassName(), exceptionType, null)));
+        }
+        });
+    }
+}

src/main/resources/META-INF/rewrite/classpath.tsv.gz

@@ -48,6 +48,7 @@ recipeList:
   - org.openrewrite.java.testing.mockito.RemovePowerMockClassExtensions
   - org.openrewrite.java.testing.mockito.PowerMockitoMockStaticToMockito
   - org.openrewrite.java.testing.mockito.PowerMockitoWhenNewToMockito
+  - org.openrewrite.java.testing.mockito.PowerMockWhiteboxToJavaReflection
   - org.openrewrite.java.testing.mockito.CleanupPowerMockImports
   - org.openrewrite.java.dependencies.RemoveDependency:
       groupId: org.powermock

src/main/resources/META-INF/rewrite/powermockito.yml

@@ -195,6 +195,7 @@ maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.tes
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.MockitoJUnitRunnerToExtension,Replace JUnit 4 MockitoJUnitRunner with junit-jupiter MockitoExtension,"Replace JUnit 4 MockitoJUnitRunner annotations with JUnit 5 `@ExtendWith(MockitoExtension.class)` using the appropriate strictness levels (LENIENT, WARN, STRICT_STUBS).",1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.MockitoWhenOnStaticToMockStatic,Replace `Mockito.when` on static (non mock) with try-with-resource with MockedStatic,"Replace `Mockito.when` on static (non mock) with try-with-resource with MockedStatic as Mockito4 no longer allows this. For JUnit 4/5 & TestNG: When `@Before*` is used, a `close` call is added to the corresponding `@After*` method. This change moves away from implicit bytecode manipulation for static method stubbing, making mocking behavior more explicit and scoped to avoid unintended side effects.",1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.PowerMockRunnerDelegateToRunWith,Replace PowerMock runner with standard `@RunWith`,"Replaces `@RunWith(PowerMockRunner.class)`. If `@PowerMockRunnerDelegate(X.class)` is present, promotes the delegate runner to `@RunWith(X.class)`. Otherwise, removes the `@RunWith(PowerMockRunner.class)` annotation entirely.",1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
+maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.PowerMockWhiteboxToJavaReflection,Replace PowerMock `Whitebox` with Java reflection,"Replace `org.powermock.reflect.Whitebox` calls (`setInternalState`, `getInternalState`, `invokeMethod`) with plain Java reflection using `java.lang.reflect.Field` and `java.lang.reflect.Method`.",1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.PowerMockitoMockStaticToMockito,Replace `PowerMock.mockStatic()` with `Mockito.mockStatic()`,Replaces `PowerMockito.mockStatic()` by `Mockito.mockStatic()`. Removes the `@PrepareForTest` annotation.,1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.PowerMockitoWhenNewToMockito,Replace `PowerMockito.whenNew` with Mockito counterpart,Replaces `PowerMockito.whenNew` calls with respective `Mockito.whenConstructed` calls.,1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.RemoveInitMocksIfRunnersSpecified,Remove `MockitoAnnotations.initMocks(this)` and `openMocks(this)` if JUnit runners specified,Remove `MockitoAnnotations.initMocks(this)` and `MockitoAnnotations.openMocks(this)` if class-level JUnit runners `@RunWith(MockitoJUnitRunner.class)` or `@ExtendWith(MockitoExtension.class)` are specified. These manual initialization calls are redundant when using Mockito's JUnit integration.,1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,