/*
 * Copyright 2014 - 2020 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.description.method;

import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import net.bytebuddy.build.HashCodeAndEqualsPlugin;
import net.bytebuddy.description.ByteCodeElement;
import net.bytebuddy.description.type.TypeDefinition;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.description.type.TypeList;
import net.bytebuddy.matcher.ElementMatcher;
import net.bytebuddy.matcher.FilterableList;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

Represents a list of parameters of a method or a constructor.
Type parameters:
<T> – The type of parameter descriptions represented by this list./**
 * Represents a list of parameters of a method or a constructor.
 *
 * @param <T> The type of parameter descriptions represented by this list.
 */
public interface ParameterList<T extends ParameterDescription> extends FilterableList<T, ParameterList<T>> {

    
Transforms this list of parameters into a list of the types of the represented parameters.
Returns:
A list of types representing the parameters of this list./**
     * Transforms this list of parameters into a list of the types of the represented parameters.
     *
     * @return A list of types representing the parameters of this list.
     */
    TypeList.Generic asTypeList();

    
Transforms the list of parameter descriptions into a list of detached tokens. All types that are matched by the provided target type matcher are substituted by TargetType. 
Params:
matcher – A matcher that indicates type substitution.
Returns:
The transformed token list./**
     * Transforms the list of parameter descriptions into a list of detached tokens. All types that are matched by the provided
     * target type matcher are substituted by {@link net.bytebuddy.dynamic.TargetType}.
     *
     * @param matcher A matcher that indicates type substitution.
     * @return The transformed token list.
     */
    ByteCodeElement.Token.TokenList<ParameterDescription.Token> asTokenList(ElementMatcher<? super TypeDescription> matcher);

    
Returns this list of these parameter descriptions resolved to their defined shape.
Returns:
A list of parameters in their defined shape./**
     * Returns this list of these parameter descriptions resolved to their defined shape.
     *
     * @return A list of parameters in their defined shape.
     */
    ParameterList<ParameterDescription.InDefinedShape> asDefined();

    
Checks if all parameters in this list define both an explicit name and an explicit modifier.
Returns:
true if all parameters in this list define both an explicit name and an explicit modifier./**
     * Checks if all parameters in this list define both an explicit name and an explicit modifier.
     *
     * @return {@code true} if all parameters in this list define both an explicit name and an explicit modifier.
     */
    boolean hasExplicitMetaData();

    
An base implementation for a ParameterList. 
Type parameters:
<S> – The type of parameter descriptions represented by this list./**
     * An base implementation for a {@link ParameterList}.
     *
     * @param <S> The type of parameter descriptions represented by this list.
     */
    abstract class AbstractBase<S extends ParameterDescription> extends FilterableList.AbstractBase<S, ParameterList<S>> implements ParameterList<S> {

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public boolean hasExplicitMetaData() {
            for (ParameterDescription parameterDescription : this) {
                if (!parameterDescription.isNamed() || !parameterDescription.hasModifiers()) {
                    return false;
                }
            }
            return true;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ByteCodeElement.Token.TokenList<ParameterDescription.Token> asTokenList(ElementMatcher<? super TypeDescription> matcher) {
            List<ParameterDescription.Token> tokens = new ArrayList<ParameterDescription.Token>(size());
            for (ParameterDescription parameterDescription : this) {
                tokens.add(parameterDescription.asToken(matcher));
            }
            return new ByteCodeElement.Token.TokenList<ParameterDescription.Token>(tokens);
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public TypeList.Generic asTypeList() {
            List<TypeDescription.Generic> types = new ArrayList<TypeDescription.Generic>(size());
            for (ParameterDescription parameterDescription : this) {
                types.add(parameterDescription.getType());
            }
            return new TypeList.Generic.Explicit(types);
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ParameterList<ParameterDescription.InDefinedShape> asDefined() {
            List<ParameterDescription.InDefinedShape> declaredForms = new ArrayList<ParameterDescription.InDefinedShape>(size());
            for (ParameterDescription parameterDescription : this) {
                declaredForms.add(parameterDescription.asDefined());
            }
            return new Explicit<ParameterDescription.InDefinedShape>(declaredForms);
        }

        @Override
        protected ParameterList<S> wrap(List<S> values) {
            return new Explicit<S>(values);
        }
    }

    
Represents a list of parameters for an executable, i.e. a Method or Constructor. 
Type parameters:
<T> – The type of the java.lang.reflect.Executable that this list represents./**
     * Represents a list of parameters for an executable, i.e. a {@link java.lang.reflect.Method} or {@link java.lang.reflect.Constructor}.
     *
     * @param <T> The type of the {@code java.lang.reflect.Executable} that this list represents.
     */
    abstract class ForLoadedExecutable<T> extends AbstractBase<ParameterDescription.InDefinedShape> {

        
The dispatcher used creating parameter list instances and for accessing java.lang.reflect.Executable instances. /**
         * The dispatcher used creating parameter list instances and for accessing {@code java.lang.reflect.Executable} instances.
         */
        private static final Dispatcher DISPATCHER = AccessController.doPrivileged(Dispatcher.CreationAction.INSTANCE);

        
The executable for which a parameter list is represented.
/**
         * The executable for which a parameter list is represented.
         */
        protected final T executable;

        
The parameter annotation source to query.
/**
         * The parameter annotation source to query.
         */
        protected final ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource;

        
Creates a new description for a loaded executable.
Params:
executable –                The executable for which a parameter list is represented.
parameterAnnotationSource – The parameter annotation source to query./**
         * Creates a new description for a loaded executable.
         *
         * @param executable                The executable for which a parameter list is represented.
         * @param parameterAnnotationSource The parameter annotation source to query.
         */
        protected ForLoadedExecutable(T executable, ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
            this.executable = executable;
            this.parameterAnnotationSource = parameterAnnotationSource;
        }

        
Creates a new list that describes the parameters of the given Constructor. 
Params:
constructor – The constructor for which the parameters should be described.
Returns:
A list describing the constructor's parameters./**
         * Creates a new list that describes the parameters of the given {@link Constructor}.
         *
         * @param constructor The constructor for which the parameters should be described.
         * @return A list describing the constructor's parameters.
         */
        public static ParameterList<ParameterDescription.InDefinedShape> of(Constructor<?> constructor) {
            return of(constructor, new ParameterDescription.ForLoadedParameter.ParameterAnnotationSource.ForLoadedConstructor(constructor));
        }

        
Creates a new list that describes the parameters of the given Constructor. 
Params:
constructor –               The constructor for which the parameters should be described.
parameterAnnotationSource – The parameter annotation source to query.
Returns:
A list describing the constructor's parameters./**
         * Creates a new list that describes the parameters of the given {@link Constructor}.
         *
         * @param constructor               The constructor for which the parameters should be described.
         * @param parameterAnnotationSource The parameter annotation source to query.
         * @return A list describing the constructor's parameters.
         */
        public static ParameterList<ParameterDescription.InDefinedShape> of(Constructor<?> constructor,
                                                                            ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
            return DISPATCHER.describe(constructor, parameterAnnotationSource);
        }

        
Creates a new list that describes the parameters of the given Method. 
Params:
method – The method for which the parameters should be described.
Returns:
A list describing the method's parameters./**
         * Creates a new list that describes the parameters of the given {@link Method}.
         *
         * @param method The method for which the parameters should be described.
         * @return A list describing the method's parameters.
         */
        public static ParameterList<ParameterDescription.InDefinedShape> of(Method method) {
            return of(method, new ParameterDescription.ForLoadedParameter.ParameterAnnotationSource.ForLoadedMethod(method));
        }

        
Creates a new list that describes the parameters of the given Method. 
Params:
method –                    The method for which the parameters should be described.
parameterAnnotationSource – The parameter annotation source to query.
Returns:
A list describing the method's parameters./**
         * Creates a new list that describes the parameters of the given {@link Method}.
         *
         * @param method                    The method for which the parameters should be described.
         * @param parameterAnnotationSource The parameter annotation source to query.
         * @return A list describing the method's parameters.
         */
        public static ParameterList<ParameterDescription.InDefinedShape> of(Method method,
                                                                            ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
            return DISPATCHER.describe(method, parameterAnnotationSource);
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public int size() {
            return DISPATCHER.getParameterCount(executable);
        }

        
A dispatcher for creating descriptions of parameter lists and for evaluating the size of an java.lang.reflect.Executable's parameters. /**
         * A dispatcher for creating descriptions of parameter lists and for evaluating the size of an {@code java.lang.reflect.Executable}'s parameters.
         */
        protected interface Dispatcher {

            
Returns the amount of parameters of a given executable..
Params:
executable – The executable for which the amount of parameters should be found.
Returns:
The amount of parameters of the given executable./**
             * Returns the amount of parameters of a given executable..
             *
             * @param executable The executable for which the amount of parameters should be found.
             * @return The amount of parameters of the given executable.
             */
            int getParameterCount(Object executable);

            
Describes a Constructor's parameters of the given VM. 
Params:
constructor –               The constructor for which the parameters should be described.
parameterAnnotationSource – The parameter annotation source to query.
Returns:
A list describing the constructor's parameters./**
             * Describes a {@link Constructor}'s parameters of the given VM.
             *
             * @param constructor               The constructor for which the parameters should be described.
             * @param parameterAnnotationSource The parameter annotation source to query.
             * @return A list describing the constructor's parameters.
             */
            ParameterList<ParameterDescription.InDefinedShape> describe(Constructor<?> constructor,
                                                                        ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource);

            
Describes a Method's parameters of the given VM. 
Params:
method –                    The method for which the parameters should be described.
parameterAnnotationSource – The parameter annotation source to query.
Returns:
A list describing the method's parameters./**
             * Describes a {@link Method}'s parameters of the given VM.
             *
             * @param method                    The method for which the parameters should be described.
             * @param parameterAnnotationSource The parameter annotation source to query.
             * @return A list describing the method's parameters.
             */
            ParameterList<ParameterDescription.InDefinedShape> describe(Method method,
                                                                        ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource);

            
A creation action for a dispatcher.
/**
             * A creation action for a dispatcher.
             */
            enum CreationAction implements PrivilegedAction<Dispatcher> {

                
The singleton instance.
/**
                 * The singleton instance.
                 */
                INSTANCE;

                
{@inheritDoc}
/**
                 * {@inheritDoc}
                 */
                @SuppressFBWarnings(value = "REC_CATCH_EXCEPTION", justification = "Exception should not be rethrown but trigger a fallback")
                public Dispatcher run() {
                    try {
                        return new Dispatcher.ForJava8CapableVm(Class.forName("java.lang.reflect.Executable").getMethod("getParameterCount"));
                    } catch (Exception ignored) {
                        return Dispatcher.ForLegacyVm.INSTANCE;
                    }
                }
            }

            
A dispatcher for a legacy VM that does not support the java.lang.reflect.Parameter type. /**
             * A dispatcher for a legacy VM that does not support the {@code java.lang.reflect.Parameter} type.
             */
            enum ForLegacyVm implements Dispatcher {

                
The singleton instance.
/**
                 * The singleton instance.
                 */
                INSTANCE;

                
{@inheritDoc}
/**
                 * {@inheritDoc}
                 */
                public int getParameterCount(Object executable) {
                    throw new IllegalStateException("Cannot dispatch method for java.lang.reflect.Executable");
                }

                
{@inheritDoc}
/**
                 * {@inheritDoc}
                 */
                public ParameterList<ParameterDescription.InDefinedShape> describe(Constructor<?> constructor,
                                                                                   ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
                    return new OfLegacyVmConstructor(constructor, parameterAnnotationSource);
                }

                
{@inheritDoc}
/**
                 * {@inheritDoc}
                 */
                public ParameterList<ParameterDescription.InDefinedShape> describe(Method method,
                                                                                   ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
                    return new OfLegacyVmMethod(method, parameterAnnotationSource);
                }
            }

            
A dispatcher for a legacy VM that does support the java.lang.reflect.Parameter type. /**
             * A dispatcher for a legacy VM that does support the {@code java.lang.reflect.Parameter} type.
             */
            @HashCodeAndEqualsPlugin.Enhance
            class ForJava8CapableVm implements Dispatcher {

                
An empty array that can be used to indicate no arguments to avoid an allocation on a reflective call.
/**
                 * An empty array that can be used to indicate no arguments to avoid an allocation on a reflective call.
                 */
                private static final Object[] NO_ARGUMENTS = new Object[0];

                
The java.lang.reflect.Executable#getParameterCount() method. /**
                 * The {@code java.lang.reflect.Executable#getParameterCount()} method.
                 */
                private final Method getParameterCount;

                
Creates a new dispatcher for a modern VM.
Params:
getParameterCount – The java.lang.reflect.Executable#getParameterCount() method./**
                 * Creates a new dispatcher for a modern VM.
                 *
                 * @param getParameterCount The {@code java.lang.reflect.Executable#getParameterCount()} method.
                 */
                protected ForJava8CapableVm(Method getParameterCount) {
                    this.getParameterCount = getParameterCount;
                }

                
{@inheritDoc}
/**
                 * {@inheritDoc}
                 */
                public int getParameterCount(Object executable) {
                    try {
                        return (Integer) getParameterCount.invoke(executable, NO_ARGUMENTS);
                    } catch (IllegalAccessException exception) {
                        throw new IllegalStateException("Cannot access java.lang.reflect.Parameter#getModifiers", exception);
                    } catch (InvocationTargetException exception) {
                        throw new IllegalStateException("Error invoking java.lang.reflect.Parameter#getModifiers", exception.getCause());
                    }
                }

                
{@inheritDoc}
/**
                 * {@inheritDoc}
                 */
                public ParameterList<ParameterDescription.InDefinedShape> describe(Constructor<?> constructor,
                                                                                   ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
                    return new OfConstructor(constructor, parameterAnnotationSource);
                }

                
{@inheritDoc}
/**
                 * {@inheritDoc}
                 */
                public ParameterList<ParameterDescription.InDefinedShape> describe(Method method,
                                                                                   ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
                    return new OfMethod(method, parameterAnnotationSource);
                }
            }
        }

        
Describes the list of Constructor parameters on a modern VM. /**
         * Describes the list of {@link Constructor} parameters on a modern VM.
         */
        protected static class OfConstructor extends ForLoadedExecutable<Constructor<?>> {

            
Creates a new description of the parameters of a constructor.
Params:
constructor –               The constructor that is represented by this instance.
parameterAnnotationSource – The parameter annotation source to query./**
             * Creates a new description of the parameters of a constructor.
             *
             * @param constructor               The constructor that is represented by this instance.
             * @param parameterAnnotationSource The parameter annotation source to query.
             */
            protected OfConstructor(Constructor<?> constructor, ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
                super(constructor, parameterAnnotationSource);
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public ParameterDescription.InDefinedShape get(int index) {
                return new ParameterDescription.ForLoadedParameter.OfConstructor(executable, index, parameterAnnotationSource);
            }
        }

        
Describes the list of Method parameters on a modern VM. /**
         * Describes the list of {@link Method} parameters on a modern VM.
         */
        protected static class OfMethod extends ForLoadedExecutable<Method> {

            
Creates a new description of the parameters of a method.
Params:
method –                    The method that is represented by this instance.
parameterAnnotationSource – The parameter annotation source to query./**
             * Creates a new description of the parameters of a method.
             *
             * @param method                    The method that is represented by this instance.
             * @param parameterAnnotationSource The parameter annotation source to query.
             */
            protected OfMethod(Method method, ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
                super(method, parameterAnnotationSource);
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public ParameterDescription.InDefinedShape get(int index) {
                return new ParameterDescription.ForLoadedParameter.OfMethod(executable, index, parameterAnnotationSource);
            }
        }

        
Represents a list of constructor parameters on virtual machines where the java.lang.reflect.Parameter type is not available. /**
         * Represents a list of constructor parameters on virtual machines where the {@code java.lang.reflect.Parameter}
         * type is not available.
         */
        protected static class OfLegacyVmConstructor extends ParameterList.AbstractBase<ParameterDescription.InDefinedShape> {

            
The represented constructor.
/**
             * The represented constructor.
             */
            private final Constructor<?> constructor;

            
An array of this method's parameter types.
/**
             * An array of this method's parameter types.
             */
            private final Class<?>[] parameterType;

            
The parameter annotation source to query.
/**
             * The parameter annotation source to query.
             */
            private final ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource;

            
Creates a legacy representation of a constructor's parameters.
Params:
constructor –               The constructor to represent.
parameterAnnotationSource – The parameter annotation source to query./**
             * Creates a legacy representation of a constructor's parameters.
             *
             * @param constructor               The constructor to represent.
             * @param parameterAnnotationSource The parameter annotation source to query.
             */
            protected OfLegacyVmConstructor(Constructor<?> constructor, ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
                this.constructor = constructor;
                this.parameterType = constructor.getParameterTypes();
                this.parameterAnnotationSource = parameterAnnotationSource;
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public ParameterDescription.InDefinedShape get(int index) {
                return new ParameterDescription.ForLoadedParameter.OfLegacyVmConstructor(constructor, index, parameterType, parameterAnnotationSource);
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public int size() {
                return parameterType.length;
            }
        }

        
Represents a list of method parameters on virtual machines where the java.lang.reflect.Parameter type is not available. /**
         * Represents a list of method parameters on virtual machines where the {@code java.lang.reflect.Parameter}
         * type is not available.
         */
        protected static class OfLegacyVmMethod extends ParameterList.AbstractBase<ParameterDescription.InDefinedShape> {

            
The represented method.
/**
             * The represented method.
             */
            private final Method method;

            
An array of this method's parameter types.
/**
             * An array of this method's parameter types.
             */
            private final Class<?>[] parameterType;

            
The parameter annotation source to query.
/**
             * The parameter annotation source to query.
             */
            private final ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource;

            
Creates a legacy representation of a method's parameters.
Params:
method –                    The method to represent.
parameterAnnotationSource – The parameter annotation source to query./**
             * Creates a legacy representation of a method's parameters.
             *
             * @param method                    The method to represent.
             * @param parameterAnnotationSource The parameter annotation source to query.
             */
            protected OfLegacyVmMethod(Method method, ParameterDescription.ForLoadedParameter.ParameterAnnotationSource parameterAnnotationSource) {
                this.method = method;
                this.parameterType = method.getParameterTypes();
                this.parameterAnnotationSource = parameterAnnotationSource;
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public ParameterDescription.InDefinedShape get(int index) {
                return new ParameterDescription.ForLoadedParameter.OfLegacyVmMethod(method, index, parameterType, parameterAnnotationSource);
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public int size() {
                return parameterType.length;
            }
        }
    }

    
A list of explicitly provided parameter descriptions.
Type parameters:
<S> – The type of parameter descriptions represented by this list./**
     * A list of explicitly provided parameter descriptions.
     *
     * @param <S> The type of parameter descriptions represented by this list.
     */
    class Explicit<S extends ParameterDescription> extends AbstractBase<S> {

        
The list of parameter descriptions that are represented by this list.
/**
         * The list of parameter descriptions that are represented by this list.
         */
        private final List<? extends S> parameterDescriptions;

        
Creates a new list of explicit parameter descriptions.
Params:
parameterDescription – The list of parameter descriptions that are represented by this list./**
         * Creates a new list of explicit parameter descriptions.
         *
         * @param parameterDescription The list of parameter descriptions that are represented by this list.
         */
        @SuppressWarnings("unchecked")
        public Explicit(S... parameterDescription) {
            this(Arrays.asList(parameterDescription));
        }

        
Creates a new list of explicit parameter descriptions.
Params:
parameterDescriptions – The list of parameter descriptions that are represented by this list./**
         * Creates a new list of explicit parameter descriptions.
         *
         * @param parameterDescriptions The list of parameter descriptions that are represented by this list.
         */
        public Explicit(List<? extends S> parameterDescriptions) {
            this.parameterDescriptions = parameterDescriptions;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public S get(int index) {
            return parameterDescriptions.get(index);
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public int size() {
            return parameterDescriptions.size();
        }

        
A parameter list representing parameters without meta data or annotations.
/**
         * A parameter list representing parameters without meta data or annotations.
         */
        public static class ForTypes extends ParameterList.AbstractBase<ParameterDescription.InDefinedShape> {

            
The method description that declares the parameters.
/**
             * The method description that declares the parameters.
             */
            private final MethodDescription.InDefinedShape methodDescription;

            
A list of detached types representing the parameters.
/**
             * A list of detached types representing the parameters.
             */
            private final List<? extends TypeDefinition> typeDefinitions;

            
Creates a new parameter type list.
Params:
methodDescription – The method description that declares the parameters.
typeDefinition –    A list of detached types representing the parameters./**
             * Creates a new parameter type list.
             *
             * @param methodDescription The method description that declares the parameters.
             * @param typeDefinition    A list of detached types representing the parameters.
             */
            public ForTypes(MethodDescription.InDefinedShape methodDescription, TypeDefinition... typeDefinition) {
                this(methodDescription, Arrays.asList(typeDefinition));
            }

            
Creates a new parameter type list.
Params:
methodDescription – The method description that declares the parameters.
typeDefinitions –   A list of detached types representing the parameters./**
             * Creates a new parameter type list.
             *
             * @param methodDescription The method description that declares the parameters.
             * @param typeDefinitions   A list of detached types representing the parameters.
             */
            public ForTypes(MethodDescription.InDefinedShape methodDescription, List<? extends TypeDefinition> typeDefinitions) {
                this.methodDescription = methodDescription;
                this.typeDefinitions = typeDefinitions;
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public ParameterDescription.InDefinedShape get(int index) {
                int offset = methodDescription.isStatic() ? 0 : 1;
                for (int previous = 0; previous < index; previous++) {
                    offset += typeDefinitions.get(previous).getStackSize().getSize();
                }
                return new ParameterDescription.Latent(methodDescription, typeDefinitions.get(index).asGenericType(), index, offset);
            }

            
{@inheritDoc}
/**
             * {@inheritDoc}
             */
            public int size() {
                return typeDefinitions.size();
            }
        }
    }

    
A list of parameter descriptions for a list of detached tokens. For the returned parameter, each token is attached to its parameter representation.
/**
     * A list of parameter descriptions for a list of detached tokens. For the returned parameter, each token is attached to its parameter representation.
     */
    class ForTokens extends AbstractBase<ParameterDescription.InDefinedShape> {

        
The method that is declaring the represented token.
/**
         * The method that is declaring the represented token.
         */
        private final MethodDescription.InDefinedShape declaringMethod;

        
The list of tokens to represent.
/**
         * The list of tokens to represent.
         */
        private final List<? extends ParameterDescription.Token> tokens;

        
Creates a new parameter list for the provided tokens.
Params:
declaringMethod – The method that is declaring the represented token.
tokens –          The list of tokens to represent./**
         * Creates a new parameter list for the provided tokens.
         *
         * @param declaringMethod The method that is declaring the represented token.
         * @param tokens          The list of tokens to represent.
         */
        public ForTokens(MethodDescription.InDefinedShape declaringMethod, List<? extends ParameterDescription.Token> tokens) {
            this.declaringMethod = declaringMethod;
            this.tokens = tokens;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ParameterDescription.InDefinedShape get(int index) {
            int offset = declaringMethod.isStatic() ? 0 : 1;
            for (ParameterDescription.Token token : tokens.subList(0, index)) {
                offset += token.getType().getStackSize().getSize();
            }
            return new ParameterDescription.Latent(declaringMethod, tokens.get(index), index, offset);
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public int size() {
            return tokens.size();
        }
    }

    
A list of parameter descriptions that yields TypeSubstituting. /**
     * A list of parameter descriptions that yields {@link net.bytebuddy.description.method.ParameterDescription.TypeSubstituting}.
     */
    class TypeSubstituting extends AbstractBase<ParameterDescription.InGenericShape> {

        
The method that is declaring the transformed parameters.
/**
         * The method that is declaring the transformed parameters.
         */
        private final MethodDescription.InGenericShape declaringMethod;

        
The untransformed parameters that are represented by this list.
/**
         * The untransformed parameters that are represented by this list.
         */
        private final List<? extends ParameterDescription> parameterDescriptions;

        
The visitor to apply to the parameter types before returning them.
/**
         * The visitor to apply to the parameter types before returning them.
         */
        private final TypeDescription.Generic.Visitor<? extends TypeDescription.Generic> visitor;

        
Creates a new type substituting parameter list.
Params:
declaringMethod –       The method that is declaring the transformed parameters.
parameterDescriptions – The untransformed parameters that are represented by this list.
visitor –               The visitor to apply to the parameter types before returning them./**
         * Creates a new type substituting parameter list.
         *
         * @param declaringMethod       The method that is declaring the transformed parameters.
         * @param parameterDescriptions The untransformed parameters that are represented by this list.
         * @param visitor               The visitor to apply to the parameter types before returning them.
         */
        public TypeSubstituting(MethodDescription.InGenericShape declaringMethod,
                                List<? extends ParameterDescription> parameterDescriptions,
                                TypeDescription.Generic.Visitor<? extends TypeDescription.Generic> visitor) {
            this.declaringMethod = declaringMethod;
            this.parameterDescriptions = parameterDescriptions;
            this.visitor = visitor;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ParameterDescription.InGenericShape get(int index) {
            return new ParameterDescription.TypeSubstituting(declaringMethod, parameterDescriptions.get(index), visitor);
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public int size() {
            return parameterDescriptions.size();
        }
    }

    
An empty list of parameters.
Type parameters:
<S> – The type of parameter descriptions represented by this list./**
     * An empty list of parameters.
     *
     * @param <S> The type of parameter descriptions represented by this list.
     */
    class Empty<S extends ParameterDescription> extends FilterableList.Empty<S, ParameterList<S>> implements ParameterList<S> {

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public boolean hasExplicitMetaData() {
            return true;
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public TypeList.Generic asTypeList() {
            return new TypeList.Generic.Empty();
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        public ByteCodeElement.Token.TokenList<ParameterDescription.Token> asTokenList(ElementMatcher<? super TypeDescription> matcher) {
            return new ByteCodeElement.Token.TokenList<ParameterDescription.Token>();
        }

        
{@inheritDoc}
/**
         * {@inheritDoc}
         */
        @SuppressWarnings("unchecked")
        public ParameterList<ParameterDescription.InDefinedShape> asDefined() {
            return (ParameterList<ParameterDescription.InDefinedShape>) this;
        }
    }
}