raphw / byte-buddy / #801

/*

 * Copyright 2014 - Present Rafael Winterhalter

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * 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 net.bytebuddy.implementation;

import net.bytebuddy.build.HashCodeAndEqualsPlugin;

import net.bytebuddy.description.field.FieldDescription;

import net.bytebuddy.description.method.MethodDescription;

import net.bytebuddy.description.method.MethodList;

import net.bytebuddy.description.type.TypeDefinition;

import net.bytebuddy.description.type.TypeDescription;

import net.bytebuddy.dynamic.scaffold.FieldLocator;

import net.bytebuddy.dynamic.scaffold.InstrumentedType;

import net.bytebuddy.dynamic.scaffold.MethodGraph;

import net.bytebuddy.implementation.bind.MethodDelegationBinder;

import net.bytebuddy.implementation.bind.annotation.TargetMethodAnnotationDrivenBinder;

import net.bytebuddy.implementation.bytecode.ByteCodeAppender;

import net.bytebuddy.implementation.bytecode.Duplication;

import net.bytebuddy.implementation.bytecode.StackManipulation;

import net.bytebuddy.implementation.bytecode.TypeCreation;

import net.bytebuddy.implementation.bytecode.assign.Assigner;

import net.bytebuddy.implementation.bytecode.member.FieldAccess;

import net.bytebuddy.implementation.bytecode.member.MethodInvocation;

import net.bytebuddy.implementation.bytecode.member.MethodVariableAccess;

import net.bytebuddy.matcher.ElementMatcher;

import net.bytebuddy.utility.CompoundList;

import net.bytebuddy.utility.RandomString;

import org.objectweb.asm.MethodVisitor;

import org.objectweb.asm.Opcodes;

import java.lang.reflect.Type;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import static net.bytebuddy.matcher.ElementMatchers.any;

import static net.bytebuddy.matcher.ElementMatchers.fieldType;

import static net.bytebuddy.matcher.ElementMatchers.isArray;

import static net.bytebuddy.matcher.ElementMatchers.isConstructor;

import static net.bytebuddy.matcher.ElementMatchers.isPrimitive;

import static net.bytebuddy.matcher.ElementMatchers.isPrivate;

import static net.bytebuddy.matcher.ElementMatchers.isStatic;

import static net.bytebuddy.matcher.ElementMatchers.named;

import static net.bytebuddy.matcher.ElementMatchers.not;

import static net.bytebuddy.matcher.ElementMatchers.returns;

import static net.bytebuddy.matcher.ElementMatchers.takesArguments;

/**

 * This implementation delegates a method call to another method which can either be {@code static} by providing

 * a reference to a {@link java.lang.Class} or an instance method when another object is provided. The potential

 * targets of the method delegation can further be filtered by applying a filter. The method delegation can be

 * customized by invoking the {@code MethodDelegation}'s several builder methods.

 * <p>&nbsp;</p>

 * <b>Without any customization, the method delegation will work as follows:</b>

 * <p>&nbsp;</p>

 * <span style="text-decoration: underline">Binding an instrumented method to a given delegate method</span>

 * <p>&nbsp;</p>

 * A method will be bound parameter by parameter. Considering a method {@code Foo#bar} being bound to a method

 * {@code Qux#baz}, the method delegation will be decided on basis of the following annotations:

 * <ul>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.Argument}:

 * This annotation will bind the {@code n}-th parameter of {@code Foo#bar} to that parameter of {@code Qux#baz}that

 * is annotated with this annotation where {@code n} is the obligatory argument of the {@code @Argument} annotation.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.AllArguments}:

 * This annotation will assign a collection of all parameters of {@code Foo#bar} to that parameter of {@code Qux#baz}

 * that is annotated with {@code AllArguments}.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.This}: A parameter

 * of {@code Qux#baz} that is annotated with {@code This} will be assigned the instance that is instrumented for

 * a non-static method.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.Super}: A parameter that is annotated with

 * this annotation is assigned a proxy that allows calling an instrumented type's super methods.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.Default}: A parameter that is annotated with

 * this annotation is assigned a proxy that allows calling an instrumented type's directly implemented interfaces'

 * default methods.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.SuperCall}: A parameter

 * of {@code Qux#baz} that is annotated with {@code SuperCall} will be assigned an instance of a type implementing both

 * {@link java.lang.Runnable} and {@link java.util.concurrent.Callable} which will invoke the instrumented method on the

 * invocation of either interface's method. The call is made using the original arguments of the method invocation.

 * The return value is only emitted for the {@link java.util.concurrent.Callable#call()} method which additionally

 * requires to catch any unchecked exceptions that might be thrown by the original method's implementation. If a

 * source method is abstract, using this annotation excludes the method with this parameter annotation from being bound

 * to this source method.

 * </li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.DefaultCall}:

 * This annotation is similar to the {@link net.bytebuddy.implementation.bind.annotation.SuperCall}

 * annotation but it invokes a default method that is compatible to this method. If a source method does not represent

 * a default method, using this annotation excludes the method with this parameter annotation from being bound to this

 * source method. For using method handles, the {@link net.bytebuddy.implementation.bind.annotation.SuperCallHandle}

 * and {@link net.bytebuddy.implementation.bind.annotation.DefaultCallHandle} annotations can be used.</li>

 * <li>The {@link net.bytebuddy.implementation.bind.annotation.SuperMethod} or

 * {@link net.bytebuddy.implementation.bind.annotation.DefaultMethod} annotations can be used on any parameter type

 * that is assignable from the {@link java.lang.reflect.Method} type. the parameter is bound a method instance that

 * allows for the reflective invocation of a super or default method. Note that this method is not equal to the intercepted

 * method but represents a synthetic accessor method. Using this annotation also causes this accessor to be {@code public}

 * which allows its outside invocation without any access checks by a security manager. For using method handles, the

 * {@link net.bytebuddy.implementation.bind.annotation.SuperCallHandle} and

 * {@link net.bytebuddy.implementation.bind.annotation.DefaultCallHandle} annotations can be used.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.Origin}: A parameter of

 * {@code Qux#baz} that is annotated with {@code Origin} is assigned a reference to either a {@link java.lang.reflect.Method},

 * a {@link java.lang.reflect.Constructor}, a {@code java.lang.reflect.Executable} or a {@link java.lang.Class} instance.

 * A {@code Method}-typed, {@code Constructor} or {@code Executable} parameter is assigned a reference to the original

 * method that is instrumented. A {@code Class}-typed parameter is assigned the type of the caller. Furthermore, {@code MethodType}

 * and {@code MethodHandle} parameters are also supported. When using the annotation on a {@link java.lang.String} type,

 * the intercepted method's {@code toString} value is injected. The same holds for a parameter of type {@code int} that receives

 * the modifiers of the instrumented method.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.StubValue}: Assigns the (boxed) default value of the

 * intercepted method's return type to the parameter. If the return type is {@code void}, {@code null} is assigned.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.Empty}: Assigns the parameter type's

 * default value, i.e. {@code null} for a reference type or zero for primitive types. This is an opportunity to

 * ignore a parameter.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.Pipe}: A parameter that is annotated

 * with this annotation is assigned a proxy for forwarding the source method invocation to another instance of the

 * same type as the declaring type of the intercepted method. <b>This annotation needs to be installed and explicitly

 * registered before it can be used.</b> See the {@link net.bytebuddy.implementation.bind.annotation.Pipe}

 * annotation's documentation for further information on how this can be done.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.Morph}: The morph annotation is similar to

 * the {@link net.bytebuddy.implementation.bind.annotation.SuperCall} annotation but allows to

 * explicitly define and therewith alter the arguments that are handed to the super method. <b>This annotation needs

 * to be installed and explicitly registered before it can be used.</b> See the documentation to the annotation for

 * further information.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.FieldValue}: Allows to access a field's value at the time

 * of the method invocation. The field's value is directly assigned to the annotated parameter.</li>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.FieldProxy}: Allows to access fields via getter

 * and setter proxies. <b>This annotation needs to be installed and explicitly registered before it can be used.</b>

 * Note that any field access requires boxing such that a use of {@link net.bytebuddy.implementation.FieldAccessor} in

 * combination with {@link net.bytebuddy.implementation.MethodDelegation#andThen(Implementation)} might be a more

 * performant alternative for implementing field getters and setters.</li>

 * </ul>

 * If a method is not annotated with any of the above methods, it will be treated as if it was annotated

 * {@link net.bytebuddy.implementation.bind.annotation.Argument} using the next

 * unbound parameter index of the source method as its parameter. This means that a method

 * {@code Qux#baz(@Argument(2) Object p1, Object p2, @Argument(0) Object p3} would be treated as if {@code p2} was annotated

 * with {@code @Argument(1)}.

 * <p>&nbsp;</p>

 * In addition, the {@link net.bytebuddy.implementation.bind.annotation.RuntimeType}

 * annotation can instruct a parameter to be bound by a

 * {@link net.bytebuddy.implementation.bytecode.assign.Assigner} with considering the

 * runtime type of the parameter.

 * <p>&nbsp;</p>

 * <span style="text-decoration: underline">Selecting among different methods that can be used for binding a method

 * of the instrumented type</span>

 * <p>&nbsp;</p>

 * When deciding between two methods {@code Foo#bar} and {@code Foo#qux} that could both be used to delegating a

 * method call, the following consideration is applied in the given order:

 * <ol>

 * <li>{@link net.bytebuddy.implementation.bind.annotation.BindingPriority}:

 * A method that is annotated with this annotation is given a specific priority where the default priority is set

 * to {@link net.bytebuddy.implementation.bind.annotation.BindingPriority#DEFAULT}

 * for non-annotated method. A method with a higher priority is considered a better target for delegation.</li>

 * <li>{@link net.bytebuddy.implementation.bind.DeclaringTypeResolver}:

 * If a target method is declared by a more specific type than another method, the method with the most specific

 * type is bound.</li>

 * <li>{@link net.bytebuddy.implementation.bind.MethodNameEqualityResolver}:

 * If a source method {@code Baz#qux} is the source method, it will rather be assigned to {@code Foo#qux} because

 * of their equal names. Similar names and case-insensitive equality are not considered.</li>

 * <li>{@link net.bytebuddy.implementation.bind.ArgumentTypeResolver}:

 * The most specific type resolver will consider all bindings that are using the

 * {@link net.bytebuddy.implementation.bind.annotation.Argument}

 * annotation for resolving a binding conflict. In this context, the resolution will equal the most-specific

 * type resolution that is performed by the Java compiler. This means that a source method {@code Bar#baz(String)}

 * will rather be bound to a method {@code Foo#bar(String)} than {@code Foo#qux(Object)} because the {@code String}

 * type is more specific than the {@code Object} type. If two methods are equally adequate by their parameter types,

 * then the method with the higher numbers of {@code @Argument} annotated parameters is considered as the better

 * delegation target.</li>

 * <li>{@link net.bytebuddy.implementation.bind.ParameterLengthResolver}:

 * If a target methods has a higher number of total parameters that were successfully bound, the method with

 * the higher number will be considered as the better delegation target.</li>

 * </ol>

 * <p>

 * Additionally, if a method is annotated by

 * {@link net.bytebuddy.implementation.bind.annotation.IgnoreForBinding},

 * it is never considered as a target for a method delegation.

 * </p>

 * <p>

 * <b>Important</b>: For invoking a method on another instance, use the {@link MethodCall} implementation. A method delegation

 * intends to bind a interceptor class and its resolution algorithm will not necessarily yield a delegation to the intercepted

 * method.

 * </p>

 *

 * @see MethodCall

 * @see net.bytebuddy.implementation.bind.annotation.TargetMethodAnnotationDrivenBinder.ParameterBinder.ForFixedValue

 */

@HashCodeAndEqualsPlugin.Enhance

public class MethodDelegation implements Implementation.Composable {

    /**

     * The implementation delegate for this method delegation.

     */

    private final ImplementationDelegate implementationDelegate;

    /**

     * A list of {@link net.bytebuddy.implementation.bind.annotation.TargetMethodAnnotationDrivenBinder.ParameterBinder}s

     * to be used by this method delegation.

     */

    private final List<TargetMethodAnnotationDrivenBinder.ParameterBinder<?>> parameterBinders;

    /**

     * The {@link net.bytebuddy.implementation.bind.MethodDelegationBinder.AmbiguityResolver}

     * to be used by this method delegation.

     */

    private final MethodDelegationBinder.AmbiguityResolver ambiguityResolver;

    /**

     * The termination handler to apply.

     */

    private final TargetMethodAnnotationDrivenBinder.TerminationHandler terminationHandler;

    /**

     * The binding resolver being used to select the relevant method binding.

     */

    private final MethodDelegationBinder.BindingResolver bindingResolver;

    /**

     * The {@link net.bytebuddy.implementation.bytecode.assign.Assigner} to be used by this method delegation.

     */

    private final Assigner assigner;

    /**

     * Creates a new method delegation.

     *

     * @param implementationDelegate The implementation delegate to use by this method delegator.

     * @param parameterBinders       The parameter binders to use by this method delegator.

     * @param ambiguityResolver      The ambiguity resolver to use by this method delegator.

     * @param bindingResolver        The binding resolver being used to select the relevant method binding.

     */

    protected MethodDelegation(ImplementationDelegate implementationDelegate,

                               List<TargetMethodAnnotationDrivenBinder.ParameterBinder<?>> parameterBinders,

                               MethodDelegationBinder.AmbiguityResolver ambiguityResolver,

                               MethodDelegationBinder.BindingResolver bindingResolver) {

                parameterBinders,

                ambiguityResolver,

                MethodDelegationBinder.TerminationHandler.Default.RETURNING,

                bindingResolver,

                Assigner.DEFAULT);

    /**

     * Creates a new method delegation.

     *

     * @param implementationDelegate The implementation delegate to use by this method delegator.

     * @param parameterBinders       The parameter binders to use by this method delegator.

     * @param ambiguityResolver      The ambiguity resolver to use by this method delegator.

     * @param terminationHandler     The termination handler to apply.

     * @param bindingResolver        The binding resolver being used to select the relevant method binding.

     * @param assigner               The assigner to be supplied by this method delegator.

     */

    private MethodDelegation(ImplementationDelegate implementationDelegate,

                             List<TargetMethodAnnotationDrivenBinder.ParameterBinder<?>> parameterBinders,

                             MethodDelegationBinder.AmbiguityResolver ambiguityResolver,

                             TargetMethodAnnotationDrivenBinder.TerminationHandler terminationHandler,

                             MethodDelegationBinder.BindingResolver bindingResolver,

    /**

     * Delegates any intercepted method to invoke a {@code static} method that is declared by the supplied type. To be considered

     * a valid delegation target, the target method must be visible and accessible to the instrumented type. This is the case if

     * the target type is either public or in the same package as the instrumented type and if the target method is either public

     * or non-private and in the same package as the instrumented type. Private methods can only be used as a delegation target if

     * the interception is targeting the instrumented type.

     *

     * @param type The target type for the delegation.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Class<?> type) {

    }

    /**

     * Delegates any intercepted method to invoke a {@code static} method that is declared by the supplied type. To be considered

     * a valid delegation target, the target method must be visible and accessible to the instrumented type. This is the case if

     * the target type is either public or in the same package as the instrumented type and if the target method is either public

     * or non-private and in the same package as the instrumented type. Private methods can only be used as a delegation target if

     * the interception is targeting the instrumented type.

     *

     * @param typeDescription The target type for the delegation.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(TypeDescription typeDescription) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target The target instance for the delegation.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target              The target instance for the delegation.

     * @param methodGraphCompiler The method graph compiler to use.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, MethodGraph.Compiler methodGraphCompiler) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target    The target instance for the delegation.

     * @param fieldName The name of the field that is holding the {@code target} instance.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, String fieldName) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target              The target instance for the delegation.

     * @param fieldName           The name of the field that is holding the {@code target} instance.

     * @param methodGraphCompiler The method graph compiler to use.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, String fieldName, MethodGraph.Compiler methodGraphCompiler) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target The target instance for the delegation.

     * @param type   The most specific type of which {@code target} should be considered. Must be a super type of the target's actual type.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, Type type) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target              The target instance for the delegation.

     * @param type                The most specific type of which {@code target} should be considered. Must be a super type of the target's actual type.

     * @param methodGraphCompiler The method graph compiler to use.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, Type type, MethodGraph.Compiler methodGraphCompiler) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target    The target instance for the delegation.

     * @param type      The most specific type of which {@code target} should be considered. Must be a super type of the target's actual type.

     * @param fieldName The name of the field that is holding the {@code target} instance.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, Type type, String fieldName) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target              The target instance for the delegation.

     * @param type                The most specific type of which {@code target} should be considered. Must be a super type of the target's actual type.

     * @param fieldName           The name of the field that is holding the {@code target} instance.

     * @param methodGraphCompiler The method graph compiler to use.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, Type type, String fieldName, MethodGraph.Compiler methodGraphCompiler) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target         The target instance for the delegation.

     * @param typeDefinition The most specific type of which {@code target} should be considered. Must be a super type of the target's actual type.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, TypeDefinition typeDefinition) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target              The target instance for the delegation.

     * @param typeDefinition      The most specific type of which {@code target} should be considered. Must be a super type of the target's actual type.

     * @param methodGraphCompiler The method graph compiler to use.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, TypeDefinition typeDefinition, MethodGraph.Compiler methodGraphCompiler) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target         The target instance for the delegation.

     * @param typeDefinition The most specific type of which {@code target} should be considered. Must be a super type of the target's actual type.

     * @param fieldName      The name of the field that is holding the {@code target} instance.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, TypeDefinition typeDefinition, String fieldName) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method that is declared by the supplied type's instance or any

     * of its super types. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param target              The target instance for the delegation.

     * @param typeDefinition      The most specific type of which {@code target} should be considered. Must be a super type of the target's actual type.

     * @param fieldName           The name of the field that is holding the {@code target} instance.

     * @param methodGraphCompiler The method graph compiler to use.

     * @return A method delegation that redirects method calls to a static method of the supplied type.

     */

    public static MethodDelegation to(Object target, TypeDefinition typeDefinition, String fieldName, MethodGraph.Compiler methodGraphCompiler) {

    }

    /**

     * Delegates any intercepted method to invoke a constructor of the supplied type. To be considered a valid delegation target,

     * a constructor must be visible and accessible to the instrumented type. This is the case if the constructor's declaring type is

     * either public or in the same package as the instrumented type and if the constructor is either public or non-private and in

     * the same package as the instrumented type. Private constructors can only be used as a delegation target if the delegation is

     * targeting the instrumented type.

     *

     * @param type The type to construct.

     * @return A delegation that redirects method calls to a constructor of the supplied type.

     */

    public static MethodDelegation toConstructor(Class<?> type) {

    }

    /**

     * Delegates any intercepted method to invoke a constructor of the supplied type. To be considered a valid delegation target,

     * a constructor must be visible and accessible to the instrumented type. This is the case if the constructor's declaring type is

     * either public or in the same package as the instrumented type and if the constructor is either public or non-private and in

     * the same package as the instrumented type. Private constructors can only be used as a delegation target if the delegation is

     * targeting the instrumented type.

     *

     * @param typeDescription The type to construct.

     * @return A delegation that redirects method calls to a constructor of the supplied type.

     */

    public static MethodDelegation toConstructor(TypeDescription typeDescription) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method on the instance of the supplied field. To be

     * considered a valid delegation target, a method must be visible and accessible to the instrumented type. This is the

     * case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param name The field's name.

     * @return A delegation that redirects invocations to a method of the specified field's instance.

     */

    public static MethodDelegation toField(String name) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method on the instance of the supplied field. To be

     * considered a valid delegation target, a method must be visible and accessible to the instrumented type. This is the

     * case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param name                The field's name.

     * @param fieldLocatorFactory The field locator factory to use.

     * @return A delegation that redirects invocations to a method of the specified field's instance.

     */

    public static MethodDelegation toField(String name, FieldLocator.Factory fieldLocatorFactory) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method on the instance of the supplied field. To be

     * considered a valid delegation target, a method must be visible and accessible to the instrumented type. This is the

     * case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param name                The field's name.

     * @param methodGraphCompiler The method graph compiler to use.

     * @return A delegation that redirects invocations to a method of the specified field's instance.

     */

    public static MethodDelegation toField(String name, MethodGraph.Compiler methodGraphCompiler) {

    }

    /**

     * Delegates any intercepted method to invoke a non-{@code static} method on the instance of the supplied field. To be

     * considered a valid delegation target, a method must be visible and accessible to the instrumented type. This is the

     * case if the method's declaring type is either public or in the same package as the instrumented type and if the method

     * is either public or non-private and in the same package as the instrumented type. Private methods can only be used as

     * a delegation target if the delegation is targeting the instrumented type.

     *

     * @param name                The field's name.

     * @param fieldLocatorFactory The field locator factory to use.

     * @param methodGraphCompiler The method graph compiler to use.

     * @return A delegation that redirects invocations to a method of the specified field's instance.

     */

    public static MethodDelegation toField(String name, FieldLocator.Factory fieldLocatorFactory, MethodGraph.Compiler methodGraphCompiler) {

    }

    /**

     * Delegates any intercepted method to invoke a method on an instance that is returned by a parameterless method of the

     * given name. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if

     * the method is either public or non-private and in the same package as the instrumented type. Private methods can only

     * be used as a delegation target if the delegation is targeting the instrumented type.

     *

     * @param name The name of the method that returns the delegation target.

     * @return A delegation that redirects invocations to the return value of a method that is declared by the instrumented type.

     */

    public static MethodDelegation toMethodReturnOf(String name) {

    }

    /**

     * Delegates any intercepted method to invoke a method on an instance that is returned by a parameterless method of the

     * given name. To be considered a valid delegation target, a method must be visible and accessible to the instrumented type.

     * This is the case if the method's declaring type is either public or in the same package as the instrumented type and if

     * the method is either public or non-private and in the same package as the instrumented type. Private methods can only

     * be used as a delegation target if the delegation is targeting the instrumented type.

     *

     * @param name                The name of the method that returns the delegation target.

     * @param methodGraphCompiler The method graph compiler to use.

     * @return A delegation that redirects invocations to the return value of a method that is declared by the instrumented type.

     */

    public static MethodDelegation toMethodReturnOf(String name, MethodGraph.Compiler methodGraphCompiler) {

    }

    /**

     * Creates a configuration builder for a method delegation that is pre-configured with the ambiguity resolvers defined by

     * {@link net.bytebuddy.implementation.bind.MethodDelegationBinder.AmbiguityResolver#DEFAULT} and the parameter binders

     * defined by {@link net.bytebuddy.implementation.bind.annotation.TargetMethodAnnotationDrivenBinder.ParameterBinder#DEFAULTS}.

     *

     * @return A method delegation configuration with pre-configuration.

     */

    public static WithCustomProperties withDefaultConfiguration() {

    }

    /**

     * Creates a configuration builder for a method delegation that does not apply any pre-configured

     * {@link net.bytebuddy.implementation.bind.MethodDelegationBinder.AmbiguityResolver}s or

     * {@link net.bytebuddy.implementation.bind.annotation.TargetMethodAnnotationDrivenBinder.ParameterBinder}s.

     *

     * @return A method delegation configuration without any pre-configuration.

     */

    public static WithCustomProperties withEmptyConfiguration() {

    }

    /**

     * Applies an assigner to the method delegation that is used for assigning method return and parameter types.

     *

     * @param assigner The assigner to apply.

     * @return A method delegation implementation that makes use of the given designer.

     */

    public Implementation.Composable withAssigner(Assigner assigner) {

                parameterBinders,

                ambiguityResolver,

                terminationHandler,

                bindingResolver,

                assigner);

    }

    /**

     * {@inheritDoc}

     */

    public Implementation andThen(Implementation implementation) {

                parameterBinders,

                ambiguityResolver,

                MethodDelegationBinder.TerminationHandler.Default.DROPPING,

                bindingResolver,

                assigner), implementation);

    }

    /**

     * {@inheritDoc}

     */

    public Composable andThen(Composable implementation) {

                parameterBinders,

                ambiguityResolver,

                MethodDelegationBinder.TerminationHandler.Default.DROPPING,

                bindingResolver,

                assigner), implementation);

    }

    /**

     * {@inheritDoc}

     */

    public InstrumentedType prepare(InstrumentedType instrumentedType) {

    }

    /**

     * {@inheritDoc}

     */

    public ByteCodeAppender appender(Target implementationTarget) {

                terminationHandler,

                assigner,

                compiled);

    }

    /**

     * An implementation delegate is responsible for executing the actual method delegation and for resolving the target methods.

     */

    protected interface ImplementationDelegate extends InstrumentedType.Prepareable {

        /**

         * A name prefix for fields.

         */

        String FIELD_NAME_PREFIX = "delegate";

        /**

         * Compiles this implementation delegate.

         *

         * @param instrumentedType The instrumented type.

         * @return A compiled implementation delegate.

         */

        Compiled compile(TypeDescription instrumentedType);

        /**

         * A compiled implementation delegate.

         */

        interface Compiled {

            /**

             * Resolves a stack manipulation that prepares the delegation invocation.

             *

             * @param instrumentedMethod The instrumented method.

             * @return A stack manipulation that is applied prior to loading arguments and executing the method call.

             */

            StackManipulation prepare(MethodDescription instrumentedMethod);

            /**

             * Resolves an invoker to use for invoking the delegation target.

             *

             * @return The method invoker to use.

             */

            MethodDelegationBinder.MethodInvoker invoke();

            /**

             * Returns a list of binding records to consider for delegation.

             *

             * @return A list of delegation binder records to consider.

             */

            List<MethodDelegationBinder.Record> getRecords();

            /**

             * A compiled implementation delegate for invoking a static method.

             */

            @HashCodeAndEqualsPlugin.Enhance

            class ForStaticCall implements Compiled {

                /**

                 * The list of records to consider.

                 */

                private final List<MethodDelegationBinder.Record> records;

                /**

                 * Creates a new compiled implementation delegate for a static method call.

                 *

                 * @param records The list of records to consider.

                 */

                /**

                 * {@inheritDoc}

                 */

                public StackManipulation prepare(MethodDescription instrumentedMethod) {

                }

                /**

                 * {@inheritDoc}

                 */

                public MethodDelegationBinder.MethodInvoker invoke() {

                }

                /**

                 * {@inheritDoc}

                 */

                public List<MethodDelegationBinder.Record> getRecords() {

                }

            }

            /**

             * A compiled implementation delegate that invokes methods on a field.

             */

            @HashCodeAndEqualsPlugin.Enhance

            class ForField implements Compiled {

                /**

                 * The field to delegate to.

                 */

                private final FieldDescription fieldDescription;

                /**

                 * The records to consider for delegation.

                 */

                private final List<MethodDelegationBinder.Record> records;

                /**

                 * Creates a new compiled implementation delegate for a field delegation.

                 *

                 * @param fieldDescription The field to delegate to.

                 * @param records          The records to consider for delegation.

                 */

                /**

                 * {@inheritDoc}

                 */

                public StackManipulation prepare(MethodDescription instrumentedMethod) {

                    }

                            ? StackManipulation.Trivial.INSTANCE

                }

                /**

                 * {@inheritDoc}

                 */

                public MethodDelegationBinder.MethodInvoker invoke() {

                }

                /**

                 * {@inheritDoc}

                 */

                public List<MethodDelegationBinder.Record> getRecords() {

                }

            }

            /**

             * A compiled implementation delegate that invokes a method on an instance that is returned by another method.

             */

            @HashCodeAndEqualsPlugin.Enhance

            class ForMethodReturn implements Compiled {

                /**

                 * The method to call for result.

                 */

                private final MethodDescription methodDescription;

                /**

                 * The records to consider for delegation.

                 */

                private final List<MethodDelegationBinder.Record> records;

                /**

                 * Creates a new compiled implementation delegate for a field delegation.

                 *

                 * @param methodDescription The method to call for result.

                 * @param records           The records to consider for delegation.

                 */

                /**

                 * {@inheritDoc}

                 */

                public StackManipulation prepare(MethodDescription instrumentedMethod) {

                    }

                            ? StackManipulation.Trivial.INSTANCE

                }

                /**

                 * {@inheritDoc}

                 */

                public MethodDelegationBinder.MethodInvoker invoke() {

                }

                /**

                 * {@inheritDoc}

                 */

                public List<MethodDelegationBinder.Record> getRecords() {

                }

            }

            /**

             * A compiled implementation delegate for a constructor delegation.

             */

            @HashCodeAndEqualsPlugin.Enhance

            class ForConstruction implements Compiled {

                /**

                 * The type to be constructed.

                 */

                private final TypeDescription typeDescription;

                /**

                 * The records to consider for delegation.

                 */

                private final List<MethodDelegationBinder.Record> records;

                /**

                 * Creates a new compiled implementation delegate for a constructor delegation.

                 *

                 * @param typeDescription The type to be constructed.

                 * @param records         The records to consider for delegation.

                 */

                /**

                 * {@inheritDoc}

                 */

                public StackManipulation prepare(MethodDescription instrumentedMethod) {

                }

                /**

                 * {@inheritDoc}

                 */

                public MethodDelegationBinder.MethodInvoker invoke() {

                }

                /**

                 * {@inheritDoc}

                 */

                public List<MethodDelegationBinder.Record> getRecords() {

                }

            }

        }

        /**

         * An implementation delegate for a static method delegation.

         */

        @HashCodeAndEqualsPlugin.Enhance

        class ForStaticMethod implements ImplementationDelegate {

            /**

             * The precompiled records.

             */

            private final List<MethodDelegationBinder.Record> records;

            /**

             * Creates a new implementation delegate for a static method delegation.

             *

             * @param records The precompiled record.

             */

            /**

             * Precompiles a static method delegation for a given list of methods.

             *

             * @param methods                The methods to consider.

             * @param methodDelegationBinder The method delegation binder to use.

             * @return An appropriate implementation delegate.

             */

            protected static ImplementationDelegate of(MethodList<?> methods, MethodDelegationBinder methodDelegationBinder) {

            }

            /**

             * {@inheritDoc}

             */

            public InstrumentedType prepare(InstrumentedType instrumentedType) {

            }

            /**

             * {@inheritDoc}

             */

            public ImplementationDelegate.Compiled compile(TypeDescription instrumentedType) {

            }

        }

        /**

         * An implementation delegate for invoking methods on a field that is declared by the instrumented type or a super type.

         */

        @HashCodeAndEqualsPlugin.Enhance

        abstract class ForField implements ImplementationDelegate {

            /**

             * The name of the field that is target of the delegation.

             */

            protected final String fieldName;

            /**

             * The method graph compiler to use.

             */

            protected final MethodGraph.Compiler methodGraphCompiler;

            /**

             * The parameter binders to use.

             */

            protected final List<? extends TargetMethodAnnotationDrivenBinder.ParameterBinder<?>> parameterBinders;

            /**

             * The matcher to use for filtering methods.

             */

            protected final ElementMatcher<? super MethodDescription> matcher;

            /**

             * Creates a new implementation delegate for a field delegation.

             *

             * @param fieldName           The name of the field that is target of the delegation.

             * @param methodGraphCompiler The method graph compiler to use.

             * @param parameterBinders    The parameter binders to use.

             * @param matcher             The matcher to use for filtering methods.

             */

            protected ForField(String fieldName,

                               MethodGraph.Compiler methodGraphCompiler,

                               List<? extends TargetMethodAnnotationDrivenBinder.ParameterBinder<?>> parameterBinders,

            /**

             * {@inheritDoc}

             */

            public Compiled compile(TypeDescription instrumentedType) {

                } else {

                }

            }