Incompatibility between MethodDelegation signature and intercepted method in ByteBuddy

[HXavier21]

Description:

I am learning ByteBuddy and encountered an issue while trying to use MethodDelegation to intercept a method. Below is my full demo:

import net.bytebuddy.ByteBuddy
import net.bytebuddy.agent.ByteBuddyAgent
import net.bytebuddy.dynamic.loading.ClassReloadingStrategy
import net.bytebuddy.implementation.MethodDelegation
import net.bytebuddy.implementation.bind.annotation.RuntimeType
import net.bytebuddy.implementation.bind.annotation.SuperCall
import net.bytebuddy.matcher.ElementMatchers
import java.util.concurrent.Callable

class InnerRequest {
    fun request(message: String) {
        println(message)
    }
}

class CustomRequest {
    fun request() {
        val message = "secret String"
        InnerRequest().request(message)
    }
}

class RequestInterceptor {
    companion object {
        @JvmStatic
        fun intercept(@RuntimeType message: String, @SuperCall zpuer: Callable<Any>) {
            println("Get secret message: $message")
            zpuer.call()
        }
    }
}

fun main() {
    ByteBuddyAgent.install()
    ByteBuddy()
        .redefine(InnerRequest::class.java)
        .method(ElementMatchers.named("request"))
        .intercept(MethodDelegation.to(RequestInterceptor::class.java))
        .make()
        .load(
            InnerRequest::class.java.classLoader,
            ClassReloadingStrategy.fromInstalledAgent()
        )

    CustomRequest().request()
}

When I run this code, I get the following error:

Exception in thread "main" java.lang.IllegalArgumentException: None of [public static final void RequestInterceptor.intercept(java.lang.String,java.util.concurrent.Callable)] allows for delegation from public final void InnerRequest.request(java.lang.String)

I understand that this error occurs because the interceptor method's signature does not match the intercepted method's signature.
To address this, I tried using Advice instead of MethodDelegation, and it worked perfectly. Here is the working version with Advice:

class RequestAdvice {
    companion object {
        @JvmStatic
        @Advice.OnMethodEnter
        fun enter(@Advice.Argument(0) message: String) {
            println("Get secret message: $message")
        }
    }
}

fun main() {
    ByteBuddyAgent.install()

    ByteBuddy()
        .redefine(InnerRequest::class.java)
        .visit(
            Advice.to(RequestAdvice::class.java)
                .on(ElementMatchers.named("request"))
        )
        .make()
        .load(
            InnerRequest::class.java.classLoader,
            ClassReloadingStrategy.fromInstalledAgent()
        )
    CustomRequest().request()
}

This approach works as expected, and the output is:

Get secret message: secret String
secret String

However, I want to achieve the same functionality using MethodDelegation instead of Advice. How can I modify my interceptor and MethodDelegation logic to make it work?

---

Additional Notes:

1. I understand that the MethodDelegation signature must match the intercepted method's signature (including parameters, return type, and static/non-static nature).
2. I want to keep the ability to access the method argument (message) and optionally call the original method (like @SuperCall does).

Any help would be greatly appreciated.

[raphw]

When you redefine and use interception, the method is replaced with a new one. The super call would then go to the overridden method. Since there is none, this does not work. With rebase, it should, but then redefinition of classes is no longer possible. Using Advice seems like the right approach here.

[HXavier21]

When you redefine and use interception, the method is replaced with a new one. The super call would then go to the overridden method. Since there is none, this does not work. With rebase, it should, but then redefinition of classes is no longer possible. Using Advice seems like the right approach here.

What are the use cases for MethodDelegate? From my understanding, MethodDelegate should be a more general-purpose implementation than Advice. For example, if I want to insert custom logic at a specific position in the middle of a function rather than at the beginning or end, Advice cannot meet this requirement.
BTW, if I use rebase, it throws an error: class redefinition failed: attempted to add a method.

[raphw]

MethodDelegation is meant to being able to carry a callback around which can involve the original method. You can emulate this with advice, but it is much more straight forward with delegation.

Advice is less straight forward, but more flexible.

[HXavier21]

So if I understand correctly, in my specific use case, only Advice would be suitable, while MethodDelegate is neither appropriate nor feasible here?
Is it completely impossible to implement this identical functionality with MethodDelegate?

@JvmStatic
@Advice.OnMethodEnter
fun enter(@Advice.Argument(0) message: String) {
    println("Get secret message: $message")
}

[raphw]

When you rebase the type, but this will transform the class shape, what prevents retransformation.