FWD » Core Development » Runtime Infrastructure

**     CA  20221212          Added support for a LambdaInvocationHandler which receives as arguments lambda 

**                           expressions to perform a direct call of the target, and avoid reflection.

   implements LambdaInvocationHandler

       * @param   f

       *          A function to invoke as target, when specified.

      @Override

      public Object invoke(Object proxy, 

                           final Method method, 

                           BiFunction<Object, Object[], Object> f, 

                           Object[] args) 

               return Utils.invoke(method, f, RecordBuffer.this, args);

               // this can't receive the lambdas, as they are statically linked with the this buffer's

               // proxy types (a ClassCastException may be raised if the instance passed as first argument at

               // the lambda is not of the expected type).

               return Utils.invoke(method, f, tempRecord, args);

            result = Utils.invoke(method, f, currentRecord, args);

                     Utils.invoke(method, f, currentRecord, oldVal);

   implements LambdaInvocationHandler

      public Object invoke(Object proxy, 

                           final Method method, 

                           BiFunction<Object, Object[], Object> f, 

                           Object[] args)

      throws Throwable

                  return Utils.invoke(method, f, buffer, args);

                  invokeReturn = Utils.invoke(method, f, buffer, args);

                  return Utils.invoke(method, f, backBuffer, args);

                  invokeReturn = Utils.invoke(method, f, backBuffer, args);

**     CA  20221212 Added support for a LambdaInvocationHandler which receives as arguments lambda expressions 

**                  to perform a direct call of the target, and avoid reflection.

import java.util.function.*;

   implements LambdaInvocationHandler

       * @param   f

       *          A function to invoke as target, when specified.

      public Object invoke(Object proxy, 

                           final Method method, 

                           BiFunction<Object, Object[], Object> f, 

                           Object[] args) 

            return Utils.invoke(method, f, dsp.bound, args);

**     CA  20221212          Added support for a LambdaInvocationHandler which receives as arguments lambda 

**                           expressions to perform a direct call of the target, and avoid reflection.

import com.goldencode.proxy.*;

   implements LambdaInvocationHandler

      public Object invoke(Object proxy, 

                           Method method, 

                           BiFunction<Object, Object[], Object> f, 

                           Object[] args) 

            return Utils.invoke(method, f, instance, args);

               // instance has switched

               f = null;

            return Utils.invoke(method, f, instance, args);

**     CA  20221220          Use lambdas to execute all public methods in an external program.

            caller.lambda = lastInvoke.lambda;

                     BaseDataType res = (BaseDataType) (lastInvoke.lambda == null 

                                                         ? lastInvoke.method.invoke(reference, args)

                                                         : lastInvoke.lambda.apply(reference, args));

      BiFunction<Object, Object[], Object> lambda = externalProcedure ? null : caller.lambda;

                                                       mthd,

                                                       lambda,

       * When not-null, a lambda target to execute directly the call, without relying on the {@link #method}. 

       */

      private final BiFunction<Object, Object[], Object> lambda;

      /**

       * @param    lambda

       *           When not-null, a lambda target to execute directly the call, without relying on the 

       *           {@link #method}. 

                               BiFunction<Object, Object[], Object> lambda,

         this.lambda = lambda;

      protected Method mthd = null;

      protected BiFunction<Object, Object[], Object> lambda = null;

      /** Already resolved internal entry. */

      protected InternalEntry ie = null;

            if (lambda != null)

               return lambda.apply(instance, param);

                     caller.lambda = value.lambda;

                  value = putCache(key, method, null, rv, true);

                  caller.lambda = value.lambda;

                  value = putCache(key, method, null, rv, true);

                  caller.lambda = value.lambda;

                  putCache(key, null, null, rv, true);

                  value = putCache(key, m, m.equals(caller.mthd) ? caller.lambda : null, rv, false);

               caller.lambda = value.lambda;

         putCache(key, null, null, rv, true);

       * @param   lambda

       *          When not-null, a lambda target to execute directly the call, without relying on the method. 

                                         Method method,

                                         BiFunction<Object, Object[], Object> lambda,

                                         ArgValidationErrors returnValue,

                                         boolean exactMatch)

         CacheValue value = new CacheValue(method, lambda, returnValue, exactMatch);

         /**

          * When not-null, a lambda target to execute directly the call, without relying on the 

          * {@link #method}. 

          */

         final BiFunction<Object, Object[], Object> lambda;

          * @param   lambda

          *          When not-null, a lambda target to execute directly the call, without relying on the 

          *          {@link #method}. 

         CacheValue(Method method, BiFunction<Object, Object[], Object> lambda, ArgValidationErrors returnValue, boolean exactMatch)

            this.lambda = lambda;

       * @param    name

       *           The external program name.

      public ExternalProcedureCaller(WorkArea wa, String name, String className, boolean persistent)

         this.ie = SourceNameMapper.getInternalEntry(name, null, false);

         this.mthd = (ie == null ? null : ie.getMethod());

         this.lambda = (ie == null ? null : ie.getLambda());

            else

            {

               res.mthd = ie.getMethod();

               res.lambda = ie.getLambda();

            }

            caller.mthd = ie.getMethod();

            caller.lambda = ie.getLambda();

               caller = new ExternalProcedureCaller(wa, name, className, persistent);

**     CA  20221220 Use lambdas to execute all public methods in an external program.  Fixed synchronization

**                  in getMethod() and getLambda(), when calling SourceNameMapper.buildLegacyProgram.

import java.util.function.*;

   private boolean isSuper = false;

   private boolean inHandle = false;

   private boolean isPrivate = false;

   /** When not-null, represents a lambda function to execute directly the target. */

   private BiFunction<Object, Object[], Object> lambda = null;

      if (method == null && extprog != null && extprog.buildLegacy && extprog.ooname == null)

         synchronized (extprog)

         {

            if (extprog.buildLegacy)

            {

               SourceNameMapper.buildLegacyProgram(extprog);

               extprog.buildLegacy = false;

            }

         }

    * Get the lambda target to be executed, see {@link #lambda}.

    * 

    * @return   See above.

    */

   public BiFunction<Object, Object[], Object> getLambda()

   {

      if (method == null && extprog != null && extprog.buildLegacy && extprog.ooname == null)

      {

         synchronized (extprog)

         {

            if (extprog.buildLegacy)

            {

               SourceNameMapper.buildLegacyProgram(extprog);

               extprog.buildLegacy = false;

            }

         }

      }

      return lambda;

   }

   /**

    * Set the target lambda for this internal entry to the specified one.

    * 

    * @param    lambda

    *           The target lambda.

    */

   void setLambda(BiFunction<Object, Object[], Object> lambda)

   {

      this.lambda = lambda;

   }

   /**

**     CA  20221220          Use lambdas to execute all public methods in an external program.

import com.goldencode.proxy.*;

      Map<Method, BiFunction<Object, Object[], Object>> lambdas = LambdaFactory.buildLambdas(cls);

               if (lambdas != null)

               {

                  BiFunction<Object, Object[], Object> lambda = lambdas.get(mthd);

                  ie.setLambda(lambda);

               }

       * Flag indicating if {@link SourceNameMapper#buildLegacyClass(Class)} needs to be called when 

       * {@link InternalEntry#getMethod()} or {@link InternalEntry#getLambda()} are accessed.

       */

      boolean buildLegacy = true;

      /**

**     CA  20221212          Added support for a LambdaInvocationHandler which receives as arguments lambda 

**                           expressions to perform a direct call of the target, and avoid reflection.

    *           The method to execute, only if the function or consumer are both null.

    * @param    f

    *           When not-null, invoke this function and return its value.

    * @param    instance

    *           The instance on which the call will be made; can be <code>null</code> for static methods.

    * @param    args

    *           The method's arguments.

    *           

    * @return   The method's return value.

    * 

    * @throws   IllegalAccessException

    * @throws   IllegalArgumentException

    * @throws   InvocationTargetException

    */

   public static Object invoke(Method method, 

                               BiFunction<Object, Object[], Object> f, 

                               Object instance, 

                               Object... args) 

   throws IllegalAccessException, 

          IllegalArgumentException, 

          InvocationTargetException

    {

      if (f != null)

      {

         return f.apply(instance, args);

      }

      else

      {

         return invoke(method, instance, args);

      }

    }

   /**

    * Invoke the specified {@link Method} using ReflectASM instead of standard reflection.

    * <p>

    * ReflectASM related data is cached in {@link #METHOD_DATA}, thread-local, to avoid the concurrent access.

    * More, the maps are identity-keyed, for fast access.

    * 

    * @param    method

/*

** Module   : DefaultHandlerPlugin.java

** Abstract : 

**

** Copyright (c) 2022, Golden Code Development Corporation.

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 CA  20221212 Created initial version.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.proxy;

import java.lang.reflect.*;

import org.objectweb.asm.*;

import com.goldencode.asm.AsmUtils;

/**

 * Assembler for the invocation arguments emitted for the {@link InvocationHandler#invoke} method.

 */

class DefaultHandlerPlugin

implements InvocationHandlerPlugin

{

   /**

    * Get the handler's class.

    * 

    * @return   {@link InvocationHandler} type.

    */

   @Override

   public Class<? extends InvocationHandler> getHandlerClass()

   {

      return InvocationHandler.class;

   }

   /**

    * Get the signature of the 'invoke' method for the {@link InvocationHandler}.

    */

   @Override

   public String getInvokeSignature()

   {

      return "(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;";

   }

   /**

    * Create the arguments related to invoking the target of this proxied call.  This will emit a {@link Method}

    * reference from within the 'ma' array at the specified 'methodIndex'.

    * 

    * @param    classWriter

    *           Class writer for proxy class.

    * @param    mv

    *           Method visitor for this method.

    * @param    proxyName

    *           Internal form of the proxy class' name.

    * @param    method

    *           Method for which this proxy is being implemented.

    * @param    methodIndex

    *           Index of this method within the array of methods used by the invocation handler.

    */

   @Override

   public void createInvocationArgs(ClassWriter   classWriter, 

                                    MethodVisitor mv, 

                                    String        proxyName, 

                                    Method        method, 

                                    int           methodIndex)

   {

      // load target method from array of methods in static field "ma"

      mv.visitFieldInsn(ProxyAssembler.GETSTATIC,

                        proxyName,

                        "ma",

                        "[Ljava/lang/reflect/Method;");

      // target method is at index "index" in the "ma" array

      AsmUtils.pushInt(mv, methodIndex);

      mv.visitInsn(Opcodes.AALOAD);

  }

}

/*

** Module   : InvocationHandlerPlugin.java

** Abstract : 

**

** Copyright (c) 2022, Golden Code Development Corporation.

**

** -#- -I- --Date-- ---------------------------------------Description----------------------------------------

** 001 CA  20221212 Created initial version.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.proxy;

import java.lang.reflect.*;

import org.objectweb.asm.*;

/**

 * Assembler for the invocation arguments emitted for the 'invoke' method at the handler.

 */

public interface InvocationHandlerPlugin

{

   /**

    * Get the handler's class.

    * 

    * @return   A sub-class of {@link InvocationHandler}.

    */

   public Class<? extends InvocationHandler> getHandlerClass();

   /**

    * Get the signature of the 'invoke' method for the {@link #getHandlerClass() handler type}.

    */

   public String getInvokeSignature();

   /**

    * Create the arguments related to invoking the target of this proxied call.  This will emit at least the

    * {@link Method} reference.

    * 

    * @param    classWriter

    *           Class writer for proxy class.

    * @param    mv

    *           Method visitor for this method.

    * @param    proxyName

    *           Internal form of the proxy class' name.

    * @param    method

    *           Method for which this proxy is being implemented.

    * @param    methodIndex

    *           Index of this method within the array of methods used by the invocation handler.

    */

   public void createInvocationArgs(ClassWriter   classWriter, 

                                    MethodVisitor mv, 

                                    String        proxyName, 

                                    Method        method, 

                                    int           methodIndex);

}

/*

** Module   : LambdaAssembler.java

** Abstract : Assembles a dynamic class which defines lambdas for all reachable public methods in a certain 

**            type.

**

** Copyright (c) 2022, Golden Code Development Corporation.

**

** -#- -I- --Date-- --------------------------------Description----------------------------------

** 001 CA  20221220 Created initial version.

*/

/*

** This program is free software: you can redistribute it and/or modify

** it under the terms of the GNU Affero General Public License as

** published by the Free Software Foundation, either version 3 of the

** License, or (at your option) any later version.

**

** This program is distributed in the hope that it will be useful,

** but WITHOUT ANY WARRANTY; without even the implied warranty of

** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

** GNU Affero General Public License for more details.

**

** You may find a copy of the GNU Affero GPL version 3 at the following

** location: https://www.gnu.org/licenses/agpl-3.0.en.html

** 

** Additional terms under GNU Affero GPL version 3 section 7:

** 

**   Under Section 7 of the GNU Affero GPL version 3, the following additional

**   terms apply to the works covered under the License.  These additional terms

**   are non-permissive additional terms allowed under Section 7 of the GNU

**   Affero GPL version 3 and may not be removed by you.

** 

**   0. Attribution Requirement.

** 

**     You must preserve all legal notices or author attributions in the covered

**     work or Appropriate Legal Notices displayed by works containing the covered

**     work.  You may not remove from the covered work any author or developer

**     credit already included within the covered work.

** 

**   1. No License To Use Trademarks.

** 

**     This license does not grant any license or rights to use the trademarks

**     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks

**     of Golden Code Development Corporation. You are not authorized to use the

**     name Golden Code, FWD, or the names of any author or contributor, for

**     publicity purposes without written authorization.

** 

**   2. No Misrepresentation of Affiliation.

** 

**     You may not represent yourself as Golden Code Development Corporation or FWD.

** 

**     You may not represent yourself for publicity purposes as associated with

**     Golden Code Development Corporation, FWD, or any author or contributor to

**     the covered work, without written authorization.

** 

**   3. No Misrepresentation of Source or Origin.

** 

**     You may not represent the covered work as solely your work.  All modified

**     versions of the covered work must be marked in a reasonable way to make it

**     clear that the modified work is not originating from Golden Code Development

**     Corporation or FWD.  All modified versions must contain the notices of

**     attribution required in this license.

*/

package com.goldencode.proxy;

import java.lang.reflect.*;

import java.util.*;

import java.util.function.*;

import org.objectweb.asm.*;

import org.objectweb.asm.Type;

import com.goldencode.asm.*;

/**

 * A class which assembles dynamic types defining lambda functions for all public, non-static, methods of

 * that type (and its super-classes and super-interfaceS).  This is done using the ASM bytecode engineering 

 * library, v5.0.4 (http://asm.ow2.org).  As a package private class, it is intended to be invoked only by the 

 * {@link LambadFactory}, which exposes a public API for the definition of new proxy objects.

 * <p>

 * This mechanism is used to replace Java reflection (via {@link Method#invoke(Object, Object...)} or 

 * ReflectASM, to perform dynamic calls.

 * <p>

 * The following pseudo-code representation is intended to convey the general structure of the generated type. 

 *  However, please note that no intermediate source code representation is produced.

 * <p>

 * <pre>

 * public final class $__[type]Lambdas 

 * {

 *    // the mapping of Method instances to the BiFunction lambda

 *    private static final HashMap lambdas = new HashMap();

 *    

 *    // get the 'lambdas' map.

 *    public static Map getLambdas() 

 *    {

 *       return lambdas;

 *    }

 *    

 *    static

 *    {

 *       try

 *       {

 *          Method m = [type].class.getDeclaredMethod("[method]", [arg types...]);

 *          lambdas.put(m, (ref, args) -> { return (([type]) ref).[method](args[0], args[1], ...); });

 *          ...

 *          // each method in the given type

 *          ...

 *       }

 *       catch (Throwable t)

 *       {

 *          throw new RuntimeException(t);

 *       }

 *    }

 * }

 * </pre>

 */

class LambdaAssembler

implements Opcodes

{

   /** The name of the static map holding the lambdas. */

   private static final String FIELD_LAMBDAS = "lambdas";

   /** Object used to create class fields, methods, etc. */

   private final ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | 

                                                           ClassWriter.COMPUTE_MAXS);

   /** The name of the type where the lambdas will be defined. */

   private final String typeName;

   /** The methods which require lambda definitions. */

   private final HashSet<Method> methods;

   /** A counter for the number of lambdas defined in this type. */

   private int lambdaNum = 0;

   /**

    * Constructor.

    * 

    * @param    typeName

    *           The name of the type where the lambdas will be defined.

    * @param    methods

    *           The methods which require lambda definitions.

    */

   LambdaAssembler(String typeName, HashSet<Method> methods)

   {

      this.typeName = AsmUtils.commonToInternalTypeName(typeName);

      this.methods = methods;

   }

   /**

    * Assemble the class in accordance with the Java class file format as specified in <u>The Java Virtual 

    * Machine Specification, Second Edition</u> by Tim Lindholm and Frank Yellin.

    * <p>

    * See the class description above for details regarding the content of the assembled class.

    * 

    * @return   Byte array containing the class definition.

    */

   public byte[] assembleClass()

   {

      // create the dynamic class

      classWriter.visit(V1_8,

                        ACC_PUBLIC | ACC_FINAL | ACC_SUPER,

                        typeName,

                        null,

                        "java/lang/Object",

                        null);

      // add a class member field for the lambda map

      classWriter.visitField(ACC_PRIVATE | ACC_STATIC | ACC_FINAL,

                             FIELD_LAMBDAS,

                             "Ljava/util/HashMap;",

                             null,

                             null);

      assembleLambdaGetter();

      assembleLambdas();

      // complete the assembly

      classWriter.visitEnd();

      // get the byte array that represents the class file

      byte[] code = classWriter.toByteArray();

      return code;

   }

   /**

    * Emit the bytecode for the lambda call.

    * 

    * @param    typeName

    *           The type where this lambda is defined.

    * @param    method

    *           The target method.

    * @param    lambdaName

    *           The name of this synthetic lambda method.

    * @param    classWriter

    *           Class writer for proxy class.

    * @param    mv

    *           Method writer, where this lambda is being invoked.

    */

   public static void emitLambdaCall(String        typeName, 

                                     Method        method, 

                                     String        lambdaName, 

                                     ClassWriter   classWriter, 

                                     MethodVisitor mv)

   {

      String retType = "Ljava/lang/Object;";

      Object[] mthdArgs = 

      { 

         Type.getMethodType("(Ljava/lang/Object;Ljava/lang/Object;)" + retType),

         new Handle(H_INVOKESTATIC, 

                    typeName, 

                    lambdaName, 

                    "(Ljava/lang/Object;[Ljava/lang/Object;)" + retType),

                    Type.getMethodType("(Ljava/lang/Object;[Ljava/lang/Object;)" + retType)

      };

      Handle h = new Handle(H_INVOKESTATIC, 

                            "java/lang/invoke/LambdaMetafactory", 

                            "metafactory", 

                            "(Ljava/lang/invoke/MethodHandles$Lookup;" + 

                            "Ljava/lang/String;Ljava/lang/invoke/MethodType;" +

                            "Ljava/lang/invoke/MethodType;" +

                            "Ljava/lang/invoke/MethodHandle;" +

                            "Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;"

                            );

      mv.visitInvokeDynamicInsn("apply", "()Ljava/util/function/BiFunction;", h, mthdArgs);

      Class<?> clazz = method.getDeclaringClass();

      if (clazz.isAnonymousClass())

      {

         classWriter.visitInnerClass(AsmUtils.commonToInternalTypeName(clazz.getName()), 

                                     AsmUtils.commonToInternalTypeName(clazz.getDeclaringClass().getName()), 

                                     clazz.getSimpleName(), 

                                     clazz.getModifiers());

      }

      classWriter.visitInnerClass("java/lang/invoke/MethodHandles$Lookup", 

                                  "java/lang/invoke/MethodHandles", 

                                  "Lookup", 

                                  ACC_PUBLIC | ACC_STATIC | ACC_FINAL);

   }

   /**

    * Emit a the bytecode for the synthetic lambda method.  This will perform the actual Java method call, 

    * by using the first lambda argument as the reference (in case of instance methods) and emiting the 

    * arguments from the second <code>Object[]</code> lambda argument.

    * <p>

    * Arguments for Java native type parameters are automatically unwrapped.

    *  

    * @param    classWriter

    *           Class writer for proxy class.

    * @param    lambdaName

    *           The name of this synthetic lambda method.

    * @param    method

    *           Method for which this proxy is being implemented.

    */

   static void emitLambdaMethod(ClassWriter classWriter, String lambdaName, Method method)

   {

      boolean isVoid = method.getReturnType() == void.class;

      String desc = "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;";

      MethodVisitor mv = classWriter.visitMethod(ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC, 

                                                 lambdaName, 

                                                 desc, 

                                                 null,

                                                 new String[0]);

      mv.visitCode();

      int maxStack = 0;

      {

         Class<?> clazz = method.getDeclaringClass();

         String clazzDesc = AsmUtils.commonToInternalTypeName(clazz);

         // TODO: null instances (static methods)

         mv.visitVarInsn(ALOAD, 0);

         mv.visitTypeInsn(CHECKCAST, clazzDesc);

         Class<?>[] parmTypes = method.getParameterTypes();

         for (int i = 0; i < parmTypes.length; i++)

         {

            TypeInfo parmInfo = ProxyUtils.getTypeInfo(method.getParameterTypes()[i]);

            maxStack += parmInfo.getWidth();

            mv.visitVarInsn(ALOAD, 1);

            AsmUtils.pushInt(mv, i);

            mv.visitInsn(AALOAD);

            MethodInfo unwrapInfo = parmInfo.getUnwrapInfo();

            String castName = parmInfo.getCastName();

            if (castName != null && !"java/lang/Object".equals(castName))

            {

               mv.visitTypeInsn(CHECKCAST, parmInfo.getCastName());

            }

            if (unwrapInfo != null)

            {

               mv.visitMethodInsn(INVOKEVIRTUAL,

                                  unwrapInfo.getClassName(),

                                  unwrapInfo.getMethodName(),

                                  unwrapInfo.getDescriptor(),

                                  false);

            }

         }

         desc = ProxyUtils.makeMethodDescriptor(method);

         boolean isStatic = Modifier.isStatic(method.getModifiers());

         boolean isIFace = clazz.isInterface();

         boolean isAbstract = Modifier.isAbstract(method.getModifiers());

         boolean isPublic = Modifier.isPublic(method.getModifiers());

         mv.visitMethodInsn(isStatic ? INVOKESTATIC : isIFace ? INVOKEINTERFACE : INVOKEVIRTUAL, 

                            clazzDesc, 

                            method.getName(), 

                            desc, 

                            isIFace);

         if (isVoid)

         {

            mv.visitInsn(ACONST_NULL);

         }

         else

         {

            TypeInfo retInfo = ProxyUtils.getTypeInfo(method.getReturnType());

            MethodInfo wrapInfo = retInfo.getWrapInfo();

            if (wrapInfo != null)

            {

               mv.visitMethodInsn(INVOKESTATIC,

                                  wrapInfo.getClassName(),

                                  wrapInfo.getMethodName(),

                                  wrapInfo.getDescriptor(),

                                  false);

            }

         }

         mv.visitInsn(ARETURN);

      }

      mv.visitMaxs(maxStack, 2);

      mv.visitEnd();

   }

   /**

    * Assemble the <code>getLambdas</code> public, static, method, which returns the {@link #FIELD_LAMBDAS} 

    * map.

    */

   private void assembleLambdaGetter()

   {

      MethodVisitor mv =

               classWriter.visitMethod(ACC_PUBLIC | ACC_STATIC,

                                       "getLambdas",

                                       "()Ljava/util/Map;",

                                       null,

                                       null);

      // get the current value of the "lambdas" static field

      mv.visitFieldInsn(GETSTATIC,

                        typeName,

                        FIELD_LAMBDAS,

                        "Ljava/util/HashMap;");

      mv.visitInsn(ARETURN);

      mv.visitMaxs(0, 0);

      mv.visitEnd();

   }

   /**

    * Assemble all lambdas, to populate the 'lambdas' map.  This will create a static constructor definition

    * where, for each {@link #methods method}, the lambda is created and put in the map.

    * <p>

    * All lambdas are a {@link BiFunction}, with <code>Object</code> as first type (the reference on which the

    * target method is being invoked), and a <code>Object[]</code> second type, with the arguments to be 

    * passed to the method call.

    */

   private void assembleLambdas()

   {

      // create the class static constructor

      MethodVisitor mv = classWriter.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);

      Label tryLblStart = new Label();

      Label tryLblEnd = new Label();

      Label catchLblStart = new Label();

      Label catchLblEnd = new Label();

      Label tryBlock = new Label();

      Label mlblStart = tryLblStart;

      Label mlblEnd = tryLblEnd;

      Label tlblStart = catchLblStart;

      Label tlblEnd = catchLblEnd;

      mv.visitLabel(new Label());

      // initialize the 'lambdas' static field

      mv.visitTypeInsn(NEW, "java/util/HashMap");