Alternative name for the factory method of proxy classes created by the Proxy method. This name is only used if the proxified method's name is equal to DefaultFactoryMethodName.

This is the default name for the factory method of a proxy class that is created by the Proxy method. If the name of the method to be proxified is equal to this name, AlternativeFactoryMethodName is used instead.

Creates a class that acts as a proxy for the specified class. The proxy implements a single method – e.g., as defined by a so-called "Functional Interface" - that calls the specified method; creating a proxy for java.lang.Object's methods is not supported. Additionally, further marker interfaces (e.g., java.io.Serializable) may be implemented.

The generated class uses the following template:

class <definingType.objectType>
 extends <definingType.theSuperclassType>
 implements <definingType.theSuperinterfaceTypes> {

 private final <ReceiverType> receiver;

 // possible additional fields for static parameters

 public "<init>"( <ReceiverType> receiver) { // the constructor
     this.receiver = receiver;
 }

 public <methodDescriptor.returnType> <methodName> <methodDescriptor.parameterTypes>{
    return/*<= if the return type is not void*/ this.receiver.<receiverMethodName>(<parameters>)
 }

 // possibly multiple bridge methods (multiple only in case of altLambdaMetaFactory usages)
}

The class, the constructor and the method are public. The field which holds the receiver object is private and final unless the receiver method is static. In this case no receiver field is generated and the constructor does not take an argument of the receiver's type.

In addition to the receiver field, additional fields holding static parameters are created if all parameters found in methodDescriptor are present, in the same order, at the end of receiverMethodDescriptor's parameters, but receiverMethodDescriptor has more parameters that precede the parameters found in methodDescriptor.

E.g., given the following two descriptors:

val methodDescriptor =
 MethodDescriptor(IntegerType, IntegerType)
val receiverMethodDescriptor =
 MethodDescriptor(IndexedSeq(DoubleType, IntegerType), IntegerType)

one additional field and constructor parameter of type double will be created. This case occurs for example with Java 8 lambda expressions that capture local variables, which are prepended to the regular parameter list.

If any of the parameters or the return type of methodDescriptor are generic types, the generated proxy will need to create a bridge method to be valid. Therefore, in these cases, bridgeMethodDescriptor must be specified. It must be identical to methodDescriptor except for all occurrences of generic types, which must be replaced with ObjectType.Object. For example, consider the Java interface java.util.Comparator that defines the generic type T and uses it in its int compare(T, T) method. This would require a bridge method int compare(Object, Object). The appropriate method descriptors for, for example, Comparator<String> would be:

// Uses "String"
methodDescriptor =
 MethodDescriptor(IndexedSeq(ObjectType.String, ObjectType.String), IntegerType)
// Uses "Object"
bridgeMethodDescriptor =
 MethodDescriptor(IndexedSeq(ObjectType.Object, ObjectType.Object), IntegerType)

The created class will always have its synthetic access flag set, as well as the VirtualTypeFlag attribute.

Creates an array of instructions that populates the given fields in declaringType from local variables (constructor parameters).

This method assumes that it creates instructions for a constructor whose parameter list matches the given fields in terms of order and field types.

It further assumes that none of the fields provided as arguments are static fields, as it would make little sense to initialize static fields through the constructor.

Creates a bridge method using the given method descriptors, name, and type.

The bridge method's parameter list and return type are dictated by bridgeMethodDescriptor. This method generates bytecode that invokes the method described by methodName and targetMethodDescriptor on declaringType. If parameters need to be cast before invocation, the appropriate bytecode will be generated as well.

Creates a public constructor that initializes the given fields.

For every Field in fields the constructor will have one parameter of the same type. The parameter list will have the same order as fields. The generated constructor will call the superclass' default constructor; i.e., the type definingType.theSuperclassType has to have a default constructor. Additionally, bytecode is generated to populate the fields from the constructor arguments.

Creates a static proxy method used by the $deserializeLambda$ method.

Creates a factory method with the appropriate instructions to create and return an instance of typeToCreate.

typeToCreate must have a constructor with a parameter list that exactly matches fieldTypes. It also must not define a method named factoryMethodName with a parameter list matching fieldTypes.

Creates the writeReplace method for a lambda proxy class. It is used to create a SerializedLambda object which holds the serialized lambda.

The parameters of the SerializedLambda class map are as following: capturingClass = definingType functionalInterfaceClass = definingType.theSuperinterfaceTypes.head (This is the functional interface) functionalInterfaceMethodName = functionalInterfaceMethodName functionalInterfaceMethodSignature = samMethodType.parameterType implMethodKind = implMethod match to REF_ implClass = implMethod.receiverType implMethodName = implMethod.name implMethodSignature = implMethod.methodDescriptor instantiatedMethodType = instantiatedMethodType capturedArgs = methodDescriptor.parameterTypes (factoryParameters, fields in Proxy)

Returns true if the given parameters identify a Java 8 method reference to an instance or interface method (i.e., a reference to a virtual method, like so: ArrayList::size or List::size). In this case, the resulting functional interface's method has one parameter more than the referenced method because the referenced method's implicit this parameter becomes explicit.

Generates an array of instructions that fill the operand stack with all parameters required by receiverMethodDescriptor from the parameters of calledMethodDescriptor. For that reason, it is expected that both method descriptors have compatible parameter and return types: i.e., that forwarderMethodDescriptor's parameters can be widened or (un)boxed to fit into receiverMethodDescriptor's parameters, and that receiverMethodDescriptor's return type can be widened or (un)boxed to fit into forwarderMethodDescriptor's return type.

If receiverMethodDescriptor has more parameters than forwarderMethodDescriptor, the missing parameters must be provided in staticParameters.

Creates a proxy method with name methodName and descriptor methodDescriptor and the bytecode instructions to execute the method receiverMethod in receiverType.

The methodDescriptors have to be identical in terms of parameter types and have to be compatible w.r.t. the return type.

Returns the instructions that return a value of type typeToBeReturned, converting typeOnStack to it first if necessary. If typeOnStack is Object, it will be treated as a generic return type and converted to the required type.