Create recipe for @InlineMe annotation replacements

build.gradle.kts

@@ -58,7 +58,8 @@ dependencies {
 
     testImplementation("org.assertj:assertj-core:latest.release")
 
-    testImplementation("com.google.guava:guava:33.0.0-jre")
+    testImplementation("com.google.errorprone:error_prone_annotations:latest.release")
+    testImplementation("com.google.guava:guava:33.4.8-jre")
     testImplementation("joda-time:joda-time:2.12.3")
     testImplementation("org.threeten:threeten-extra:1.8.0")
 

src/main/java/org/openrewrite/java/migrate/InlineMethodCalls.java

@@ -0,0 +1,241 @@
+/*
+ * Copyright 2025 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.migrate;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Value;
+import org.jspecify.annotations.Nullable;
+import org.openrewrite.Cursor;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.java.JavaParser;
+import org.openrewrite.java.JavaTemplate;
+import org.openrewrite.java.JavaVisitor;
+import org.openrewrite.java.tree.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import static java.util.Objects.requireNonNull;
+
+public class InlineMethodCalls extends Recipe {
+
+    private static final String INLINE_ME = "com.google.errorprone.annotations.InlineMe";
+
+    @Override
+    public String getDisplayName() {
+        return "Inline methods annotated with `@InlineMe`";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Apply inlinings defined by Error Prone's [`@InlineMe` annotation](https://errorprone.info/docs/inlineme).";
+    }
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        // XXX Preconditions can not yet pick up the `@InlineMe` annotation on methods used
+        return new JavaVisitor<ExecutionContext>() {
+            @Override
+            public J visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
+                J.MethodInvocation mi = (J.MethodInvocation) super.visitMethodInvocation(method, ctx);
+                InlineMeValues values = findInlineMeValues(mi.getMethodType());
+                if (values == null) {
+                    return mi;
+                }
+                Template template = values.template(mi);
+                if (template == null) {
+                    return mi;
+                }
+                for (String importStr : values.getImports()) {
+                    maybeAddImport(importStr);
+                }
+                // TODO Add static imports
+                J replacement = JavaTemplate.builder(template.getString())
+                        .contextSensitive()
+                        .imports(values.getImports())
+                        .staticImports(values.getStaticImports())
+                        .javaParser(JavaParser.fromJavaVersion().classpath(JavaParser.runtimeClasspath()))
+                        .build()
+                        .apply(updateCursor(mi), mi.getCoordinates().replace(), template.getParameters());
+                return avoidMethodSelfReferences(mi, replacement);
+            }
+
+            @Override
+            public J visitNewClass(J.NewClass newClass, ExecutionContext ctx) {
+                J.NewClass nc = (J.NewClass) super.visitNewClass(newClass, ctx);
+                InlineMeValues values = findInlineMeValues(nc.getConstructorType());
+                if (values == null) {
+                    return nc;
+                }
+                Template template = values.template(nc);
+                if (template == null) {
+                    return nc;
+                }
+                for (String importStr : values.getImports()) {
+                    maybeAddImport(importStr);
+                }
+                // TODO Add static imports
+                J replacement = JavaTemplate.builder(template.getString())
+                        .contextSensitive()
+                        .imports(values.getImports())
+                        .staticImports(values.getStaticImports())
+                        .javaParser(JavaParser.fromJavaVersion().classpath(JavaParser.runtimeClasspath()))
+                        .build()
+                        .apply(updateCursor(nc), nc.getCoordinates().replace(), template.getParameters());
+                return avoidMethodSelfReferences(nc, replacement);
+            }
+
+            private @Nullable InlineMeValues findInlineMeValues(JavaType.@Nullable Method methodType) {
+                if (methodType == null) {
+                    return null;
+                }
+                List<JavaType.FullyQualified> annotations = methodType.getAnnotations();
+                for (JavaType.FullyQualified annotation : annotations) {
+                    if (INLINE_ME.equals(annotation.getFullyQualifiedName())) {
+                        return InlineMeValues.parse((JavaType.Annotation) annotation);
+                    }
+                }
+                return null;
+            }
+
+            private J avoidMethodSelfReferences(MethodCall original, J replacement) {
+                JavaType.Method replacementMethodType = replacement instanceof MethodCall ?
+                        ((MethodCall) replacement).getMethodType() : null;
+                if (replacementMethodType == null) {
+                    return replacement;
+                }
+
+                Cursor cursor = getCursor();
+                while ((cursor = cursor.getParent()) != null) {
+                    Object value = cursor.getValue();
+
+                    JavaType.Method cursorMethodType;
+                    if (value instanceof MethodCall) {
+                        cursorMethodType = ((MethodCall) value).getMethodType();
+                    } else if (value instanceof J.MethodDeclaration) {
+                        cursorMethodType = ((J.MethodDeclaration) value).getMethodType();
+                    } else {
+                        continue;
+                    }
+                    if (TypeUtils.isOfType(replacementMethodType, cursorMethodType)) {
+                        return original;
+                    }
+                }
+                return replacement;
+            }
+        };
+    }
+
+    @Value
+    private static class InlineMeValues {
+        private static final Pattern TEMPLATE_IDENTIFIER = Pattern.compile("#\\{(\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*):any\\(.*?\\)}");
+
+        @Getter(AccessLevel.NONE)
+        String replacement;
+
+        String[] imports;
+        String[] staticImports;
+
+        static InlineMeValues parse(JavaType.Annotation annotation) {
+            Map<String, Object> collect = annotation.getValues().stream()
+                    .collect(Collectors.toMap(
+                            e -> ((JavaType.Method) e.getElement()).getName(),
+                            JavaType.Annotation.ElementValue::getValue
+                    ));
+            String replacement = (String) collect.get("replacement");
+
+            // Parse imports and static imports from the annotation values
+            String[] imports = parseImports(collect.get("imports"));
+            String[] staticImports = parseImports(collect.get("staticImports"));
+
+            return new InlineMeValues(replacement, imports, staticImports);
+        }
+
+        private static String[] parseImports(@Nullable Object importsValue) {
+            if (importsValue instanceof List) {
+                return ((List<?>) importsValue).stream()
+                        .map(Object::toString)
+                        .toArray(String[]::new);
+            }
+            return new String[]{};
+        }
+
+        @Nullable
+        Template template(MethodCall original) {
+            JavaType.Method methodType = original.getMethodType();
+            if (methodType == null) {
+                return null;
+            }
+            String templateString = createTemplateString(original, replacement, methodType.getParameterNames());
+            List<Object> parameters = createParameters(templateString, original);
+            return new Template(templateString, parameters.toArray(new Object[0]));
+        }
+
+        private static String createTemplateString(MethodCall original, String replacement, List<String> originalParameterNames) {
+            String templateString = original instanceof J.MethodInvocation &&
+                    ((J.MethodInvocation) original).getSelect() == null &&
+                    replacement.startsWith("this.") ?
+                    replacement.replaceFirst("^this.\\b", "") :
+                    replacement.replaceAll("\\bthis\\b", "#{this:any()}");
+            for (String parameterName : originalParameterNames) {
+                // Replace parameter names with their values in the templateString
+                templateString = templateString.replaceAll(
+                        String.format("\\b%s\\b", parameterName),
+                        String.format("#{%s:any()}", parameterName)); // TODO 2nd, 3rd etc should use shorthand `#{a}`
+            }
+            return templateString;
+        }
+
+        private static List<Object> createParameters(String templateString, MethodCall original) {
+            Map<String, Expression> lookup = new HashMap<>();
+            if (original instanceof J.MethodInvocation) {
+                Expression select = ((J.MethodInvocation) original).getSelect();
+                if (select != null) {
+                    lookup.put("this", select);
+                }
+            }
+            List<String> originalParameterNames = requireNonNull(original.getMethodType()).getParameterNames();
+            for (int i = 0; i < originalParameterNames.size(); i++) {
+                String originalName = originalParameterNames.get(i);
+                Expression originalValue = original.getArguments().get(i);
+                lookup.put(originalName, originalValue);
+            }
+            List<Object> parameters = new ArrayList<>();
+            Matcher matcher = TEMPLATE_IDENTIFIER.matcher(templateString);
+            while (matcher.find()) {
+                Expression o = lookup.get(matcher.group(1));
+                if (o != null) {
+                    parameters.add(o);
+                }
+            }
+            return parameters;
+        }
+    }
+
+    @Value
+    private static class Template {
+        String string;
+        Object[] parameters;
+    }
+}