src/java.base/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java - master - wstartsev/jdk

src/java.base/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java
574 строки29 KB
Chen Liang
8343064: ClassFormatError: Illegal class name from InnerClassLambdaMetafactory
14 ноя 2024, 20:55
14 ноя 2024, 20:55681a57f
/*
 * Copyright (c) 2012, 2024, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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 General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package java.lang.invoke;

import jdk.internal.constant.ClassOrInterfaceDescImpl;
import jdk.internal.misc.CDS;
import jdk.internal.util.ClassFileDumper;
import sun.invoke.util.VerifyAccess;

import java.io.Serializable;
import java.lang.classfile.ClassBuilder;
import java.lang.classfile.ClassFile;
import java.lang.classfile.CodeBuilder;
import java.lang.classfile.MethodBuilder;
import java.lang.classfile.Opcode;
import java.lang.classfile.TypeKind;
import java.lang.constant.ClassDesc;
import java.lang.constant.MethodTypeDesc;
import java.lang.reflect.Modifier;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;

import static java.lang.classfile.ClassFile.*;
import java.lang.classfile.attribute.ExceptionsAttribute;
import java.lang.classfile.constantpool.ClassEntry;
import java.lang.classfile.constantpool.ConstantPoolBuilder;

import static java.lang.constant.ConstantDescs.*;
import static java.lang.invoke.MethodHandleNatives.Constants.NESTMATE_CLASS;
import static java.lang.invoke.MethodHandleNatives.Constants.STRONG_LOADER_LINK;
import jdk.internal.constant.ConstantUtils;
import jdk.internal.constant.MethodTypeDescImpl;
import jdk.internal.vm.annotation.Stable;
import sun.invoke.util.Wrapper;

/**
 * Lambda metafactory implementation which dynamically creates an
 * inner-class-like class per lambda callsite.
 *
 * @see LambdaMetafactory
 */
/* package */ final class InnerClassLambdaMetafactory extends AbstractValidatingLambdaMetafactory {
    private static final String LAMBDA_INSTANCE_FIELD = "LAMBDA_INSTANCE$";
    private static final @Stable String[] ARG_NAME_CACHE = {"arg$1", "arg$2", "arg$3", "arg$4", "arg$5", "arg$6", "arg$7", "arg$8"};
    private static final ClassDesc[] EMPTY_CLASSDESC_ARRAY = ConstantUtils.EMPTY_CLASSDESC;

    // For dumping generated classes to disk, for debugging purposes
    private static final ClassFileDumper lambdaProxyClassFileDumper;

    private static final boolean disableEagerInitialization;

    static {
        // To dump the lambda proxy classes, set this system property:
        //    -Djdk.invoke.LambdaMetafactory.dumpProxyClassFiles
        // or -Djdk.invoke.LambdaMetafactory.dumpProxyClassFiles=true
        final String dumpProxyClassesKey = "jdk.invoke.LambdaMetafactory.dumpProxyClassFiles";
        lambdaProxyClassFileDumper = ClassFileDumper.getInstance(dumpProxyClassesKey, "DUMP_LAMBDA_PROXY_CLASS_FILES");

        final String disableEagerInitializationKey = "jdk.internal.lambda.disableEagerInitialization";
        disableEagerInitialization = Boolean.getBoolean(disableEagerInitializationKey);
    }

    // See context values in AbstractValidatingLambdaMetafactory
    private final ClassDesc implMethodClassDesc;     // Name of type containing implementation "CC"
    private final String implMethodName;             // Name of implementation method "impl"
    private final MethodTypeDesc implMethodDesc;     // Type descriptor for implementation methods "(I)Ljava/lang/String;"
    private final MethodType constructorType;        // Generated class constructor type "(CC)void"
    private final MethodTypeDesc constructorTypeDesc;// Type descriptor for the generated class constructor type "(CC)void"
    private final ClassDesc[] argDescs;              // Type descriptors for the constructor arguments
    private final String lambdaClassName;            // Generated name for the generated class "X$$Lambda$1"
    private final ConstantPoolBuilder pool = ConstantPoolBuilder.of();
    private final ClassEntry lambdaClassEntry;       // Class entry for the generated class "X$$Lambda$1"
    private final boolean useImplMethodHandle;       // use MethodHandle invocation instead of symbolic bytecode invocation

    /**
     * General meta-factory constructor, supporting both standard cases and
     * allowing for uncommon options such as serialization or bridging.
     *
     * @param caller Stacked automatically by VM; represents a lookup context
     *               with the accessibility privileges of the caller.
     * @param factoryType Stacked automatically by VM; the signature of the
     *                    invoked method, which includes the expected static
     *                    type of the returned lambda object, and the static
     *                    types of the captured arguments for the lambda.  In
     *                    the event that the implementation method is an
     *                    instance method, the first argument in the invocation
     *                    signature will correspond to the receiver.
     * @param interfaceMethodName Name of the method in the functional interface to
     *                   which the lambda or method reference is being
     *                   converted, represented as a String.
     * @param interfaceMethodType Type of the method in the functional interface to
     *                            which the lambda or method reference is being
     *                            converted, represented as a MethodType.
     * @param implementation The implementation method which should be called (with
     *                       suitable adaptation of argument types, return types,
     *                       and adjustment for captured arguments) when methods of
     *                       the resulting functional interface instance are invoked.
     * @param dynamicMethodType The signature of the primary functional
     *                          interface method after type variables are
     *                          substituted with their instantiation from
     *                          the capture site
     * @param isSerializable Should the lambda be made serializable?  If set,
     *                       either the target type or one of the additional SAM
     *                       types must extend {@code Serializable}.
     * @param altInterfaces Additional interfaces which the lambda object
     *                      should implement.
     * @param altMethods Method types for additional signatures to be
     *                   implemented by invoking the implementation method
     * @throws LambdaConversionException If any of the meta-factory protocol
     *         invariants are violated
     */
    public InnerClassLambdaMetafactory(MethodHandles.Lookup caller,
                                       MethodType factoryType,
                                       String interfaceMethodName,
                                       MethodType interfaceMethodType,
                                       MethodHandle implementation,
                                       MethodType dynamicMethodType,
                                       boolean isSerializable,
                                       Class<?>[] altInterfaces,
                                       MethodType[] altMethods)
            throws LambdaConversionException {
        super(caller, factoryType, interfaceMethodName, interfaceMethodType,
              implementation, dynamicMethodType,
              isSerializable, altInterfaces, altMethods);
        implMethodClassDesc = implClassDesc(implClass);
        implMethodName = implInfo.getName();
        implMethodDesc = methodDesc(implInfo.getMethodType());
        constructorType = factoryType.changeReturnType(Void.TYPE);
        lambdaClassName = lambdaClassName(targetClass);
        lambdaClassEntry = pool.classEntry(ConstantUtils.internalNameToDesc(lambdaClassName));
        // If the target class invokes a protected method inherited from a
        // superclass in a different package, or does 'invokespecial', the
        // lambda class has no access to the resolved method, or does
        // 'invokestatic' on a hidden class which cannot be resolved by name.
        // Instead, we need to pass the live implementation method handle to
        // the proxy class to invoke directly. (javac prefers to avoid this
        // situation by generating bridges in the target class)
        useImplMethodHandle = (Modifier.isProtected(implInfo.getModifiers()) &&
                               !VerifyAccess.isSamePackage(targetClass, implInfo.getDeclaringClass())) ||
                               implKind == MethodHandleInfo.REF_invokeSpecial ||
                               implKind == MethodHandleInfo.REF_invokeStatic && implClass.isHidden();
        int parameterCount = factoryType.parameterCount();
        ClassDesc[] argDescs;
        MethodTypeDesc constructorTypeDesc;
        if (parameterCount > 0) {
            argDescs = new ClassDesc[parameterCount];
            for (int i = 0; i < parameterCount; i++) {
                argDescs[i] = classDesc(factoryType.parameterType(i));
            }
            constructorTypeDesc = MethodTypeDescImpl.ofValidated(CD_void, argDescs);
        } else {
            argDescs = EMPTY_CLASSDESC_ARRAY;
            constructorTypeDesc = MTD_void;
        }
        this.argDescs = argDescs;
        this.constructorTypeDesc = constructorTypeDesc;
    }

    private static String argName(int i) {
        return i < ARG_NAME_CACHE.length ? ARG_NAME_CACHE[i] :  "arg$" + (i + 1);
    }

    private static String sanitizedTargetClassName(Class<?> targetClass) {
        String name = targetClass.getName();
        if (targetClass.isHidden()) {
            // use the original class name
            name = name.replace('/', '_');
        }
        return name.replace('.', '/');
    }

    private static String lambdaClassName(Class<?> targetClass) {
        return sanitizedTargetClassName(targetClass).concat("$$Lambda");
    }

    /**
     * Build the CallSite. Generate a class file which implements the functional
     * interface, define the class, if there are no parameters create an instance
     * of the class which the CallSite will return, otherwise, generate handles
     * which will call the class' constructor.
     *
     * @return a CallSite, which, when invoked, will return an instance of the
     * functional interface
     * @throws LambdaConversionException If properly formed functional interface
     * is not found
     */
    @Override
    CallSite buildCallSite() throws LambdaConversionException {
        final Class<?> innerClass = spinInnerClass();
        if (factoryType.parameterCount() == 0 && disableEagerInitialization) {
            try {
                return new ConstantCallSite(caller.findStaticGetter(innerClass, LAMBDA_INSTANCE_FIELD,
                                                                    factoryType.returnType()));
            } catch (ReflectiveOperationException e) {
                throw new LambdaConversionException(
                        "Exception finding " + LAMBDA_INSTANCE_FIELD + " static field", e);
            }
        } else {
            try {
                MethodHandle mh = caller.findConstructor(innerClass, constructorType);
                if (factoryType.parameterCount() == 0) {
                    // In the case of a non-capturing lambda, we optimize linkage by pre-computing a single instance
                    Object inst = mh.invokeBasic();
                    return new ConstantCallSite(MethodHandles.constant(interfaceClass, inst));
                } else {
                    return new ConstantCallSite(mh.asType(factoryType));
                }
            } catch (ReflectiveOperationException e) {
                throw new LambdaConversionException("Exception finding constructor", e);
            } catch (Throwable e) {
                throw new LambdaConversionException("Exception instantiating lambda object", e);
            }
        }
    }

    /**
     * Spins the lambda proxy class.
     *
     * This first checks if a lambda proxy class can be loaded from CDS archive.
     * Otherwise, generate the lambda proxy class. If CDS dumping is enabled, it
     * registers the lambda proxy class for including into the CDS archive.
     */
    private Class<?> spinInnerClass() throws LambdaConversionException {
        // CDS does not handle disableEagerInitialization or useImplMethodHandle
        if (!disableEagerInitialization && !useImplMethodHandle) {
            if (CDS.isUsingArchive()) {
                // load from CDS archive if present
                Class<?> innerClass = LambdaProxyClassArchive.find(targetClass,
                                                                   interfaceMethodName,
                                                                   factoryType,
                                                                   interfaceMethodType,
                                                                   implementation,
                                                                   dynamicMethodType,
                                                                   isSerializable,
                                                                   altInterfaces,
                                                                   altMethods);
                if (innerClass != null) return innerClass;
            }

            // include lambda proxy class in CDS archive at dump time
            if (CDS.isDumpingArchive()) {
                Class<?> innerClass = generateInnerClass();
                LambdaProxyClassArchive.register(targetClass,
                                                 interfaceMethodName,
                                                 factoryType,
                                                 interfaceMethodType,
                                                 implementation,
                                                 dynamicMethodType,
                                                 isSerializable,
                                                 altInterfaces,
                                                 altMethods,
                                                 innerClass);
                return innerClass;
            }

        }
        return generateInnerClass();
    }

    /**
     * Generate a class file which implements the functional
     * interface, define and return the class.
     *
     * @return a Class which implements the functional interface
     * @throws LambdaConversionException If properly formed functional interface
     * is not found
     */
    private Class<?> generateInnerClass() throws LambdaConversionException {
        List<ClassDesc> interfaces;
        ClassDesc interfaceDesc = classDesc(interfaceClass);
        boolean accidentallySerializable = !isSerializable && Serializable.class.isAssignableFrom(interfaceClass);
        if (altInterfaces.length == 0) {
            interfaces = List.of(interfaceDesc);
        } else {
            // Assure no duplicate interfaces (ClassFormatError)
            Set<ClassDesc> itfs = LinkedHashSet.newLinkedHashSet(altInterfaces.length + 1);
            itfs.add(interfaceDesc);
            for (Class<?> i : altInterfaces) {
                itfs.add(classDesc(i));
                accidentallySerializable |= !isSerializable && Serializable.class.isAssignableFrom(i);
            }
            interfaces = List.copyOf(itfs);
        }
        final boolean finalAccidentallySerializable = accidentallySerializable;
        final byte[] classBytes = ClassFile.of().build(lambdaClassEntry, pool, new Consumer<ClassBuilder>() {
            @Override
            public void accept(ClassBuilder clb) {
                clb.withFlags(ACC_SUPER | ACC_FINAL | ACC_SYNTHETIC)
                   .withInterfaceSymbols(interfaces);
                // Generate final fields to be filled in by constructor
                for (int i = 0; i < argDescs.length; i++) {
                    clb.withField(argName(i), argDescs[i], ACC_PRIVATE | ACC_FINAL);
                }

                generateConstructor(clb);

                if (factoryType.parameterCount() == 0 && disableEagerInitialization) {
                    generateClassInitializer(clb);
                }

                // Forward the SAM method
                clb.withMethodBody(interfaceMethodName,
                        methodDesc(interfaceMethodType),
                        ACC_PUBLIC,
                        forwardingMethod(interfaceMethodType));

                // Forward the bridges
                if (altMethods != null) {
                    for (MethodType mt : altMethods) {
                        clb.withMethodBody(interfaceMethodName,
                                methodDesc(mt),
                                ACC_PUBLIC | ACC_BRIDGE,
                                forwardingMethod(mt));
                    }
                }

                if (isSerializable)
                    generateSerializationFriendlyMethods(clb);
                else if (finalAccidentallySerializable)
                    generateSerializationHostileMethods(clb);
            }
        });

        // Define the generated class in this VM.

        try {
            // this class is linked at the indy callsite; so define a hidden nestmate
            var classdata = useImplMethodHandle? implementation : null;
            return caller.makeHiddenClassDefiner(lambdaClassName, classBytes, lambdaProxyClassFileDumper, NESTMATE_CLASS | STRONG_LOADER_LINK)
                         .defineClass(!disableEagerInitialization, classdata);

        } catch (Throwable t) {
            throw new InternalError(t);
        }
    }

    /**
     * Generate a static field and a static initializer that sets this field to an instance of the lambda
     */
    private void generateClassInitializer(ClassBuilder clb) {
        ClassDesc lambdaTypeDescriptor = classDesc(factoryType.returnType());

        // Generate the static final field that holds the lambda singleton
        clb.withField(LAMBDA_INSTANCE_FIELD, lambdaTypeDescriptor, ACC_PRIVATE | ACC_STATIC | ACC_FINAL);

        // Instantiate the lambda and store it to the static final field
        clb.withMethodBody(CLASS_INIT_NAME, MTD_void, ACC_STATIC, new Consumer<>() {
            @Override
            public void accept(CodeBuilder cob) {
                assert factoryType.parameterCount() == 0;
                cob.new_(lambdaClassEntry)
                   .dup()
                   .invokespecial(pool.methodRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(INIT_NAME, constructorTypeDesc)))
                   .putstatic(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(LAMBDA_INSTANCE_FIELD, lambdaTypeDescriptor)))
                   .return_();
            }
        });
    }

    /**
     * Generate the constructor for the class
     */
    private void generateConstructor(ClassBuilder clb) {
        // Generate constructor
        clb.withMethodBody(INIT_NAME, constructorTypeDesc, ACC_PRIVATE,
                new Consumer<>() {
                    @Override
                    public void accept(CodeBuilder cob) {
                        cob.aload(0)
                           .invokespecial(CD_Object, INIT_NAME, MTD_void);
                        int parameterCount = factoryType.parameterCount();
                        for (int i = 0; i < parameterCount; i++) {
                            cob.aload(0)
                               .loadLocal(TypeKind.from(factoryType.parameterType(i)), cob.parameterSlot(i))
                               .putfield(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(argName(i), argDescs[i])));
                        }
                        cob.return_();
                    }
                });
    }

    private static class SerializationSupport {
        // Serialization support
        private static final ClassDesc CD_SerializedLambda = ClassOrInterfaceDescImpl.ofValidated("Ljava/lang/invoke/SerializedLambda;");
        private static final ClassDesc CD_ObjectOutputStream = ClassOrInterfaceDescImpl.ofValidated("Ljava/io/ObjectOutputStream;");
        private static final ClassDesc CD_ObjectInputStream = ClassOrInterfaceDescImpl.ofValidated("Ljava/io/ObjectInputStream;");
        private static final MethodTypeDesc MTD_Object = MethodTypeDescImpl.ofValidated(CD_Object);
        private static final MethodTypeDesc MTD_void_ObjectOutputStream = MethodTypeDescImpl.ofValidated(CD_void, CD_ObjectOutputStream);
        private static final MethodTypeDesc MTD_void_ObjectInputStream = MethodTypeDescImpl.ofValidated(CD_void, CD_ObjectInputStream);

        private static final String NAME_METHOD_WRITE_REPLACE = "writeReplace";
        private static final String NAME_METHOD_READ_OBJECT = "readObject";
        private static final String NAME_METHOD_WRITE_OBJECT = "writeObject";

        static final ClassDesc CD_NotSerializableException = ClassOrInterfaceDescImpl.ofValidated("Ljava/io/NotSerializableException;");
        static final MethodTypeDesc MTD_CTOR_NOT_SERIALIZABLE_EXCEPTION = MethodTypeDescImpl.ofValidated(CD_void, CD_String);
        static final MethodTypeDesc MTD_CTOR_SERIALIZED_LAMBDA = MethodTypeDescImpl.ofValidated(CD_void,
                CD_Class, CD_String, CD_String, CD_String, CD_int, CD_String, CD_String, CD_String, CD_String, ConstantUtils.CD_Object_array);

    }

    /**
     * Generate a writeReplace method that supports serialization
     */
    private void generateSerializationFriendlyMethods(ClassBuilder clb) {
        clb.withMethodBody(SerializationSupport.NAME_METHOD_WRITE_REPLACE, SerializationSupport.MTD_Object, ACC_PRIVATE | ACC_FINAL,
                new Consumer<>() {
                    @Override
                    public void accept(CodeBuilder cob) {
                        cob.new_(SerializationSupport.CD_SerializedLambda)
                           .dup()
                           .ldc(ClassDesc.ofInternalName(sanitizedTargetClassName(targetClass)))
                           .ldc(factoryType.returnType().getName().replace('.', '/'))
                           .ldc(interfaceMethodName)
                           .ldc(interfaceMethodType.toMethodDescriptorString())
                           .ldc(implInfo.getReferenceKind())
                           .ldc(implInfo.getDeclaringClass().getName().replace('.', '/'))
                           .ldc(implInfo.getName())
                           .ldc(implInfo.getMethodType().toMethodDescriptorString())
                           .ldc(dynamicMethodType.toMethodDescriptorString())
                           .loadConstant(argDescs.length)
                           .anewarray(CD_Object);
                        for (int i = 0; i < argDescs.length; i++) {
                            cob.dup()
                               .loadConstant(i)
                               .aload(0)
                               .getfield(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(argName(i), argDescs[i])));
                            TypeConvertingMethodAdapter.boxIfTypePrimitive(cob, TypeKind.from(argDescs[i]));
                            cob.aastore();
                        }
                        cob.invokespecial(SerializationSupport.CD_SerializedLambda, INIT_NAME,
                                          SerializationSupport.MTD_CTOR_SERIALIZED_LAMBDA)
                           .areturn();
                    }
                });
    }

    /**
     * Generate a readObject/writeObject method that is hostile to serialization
     */
    private void generateSerializationHostileMethods(ClassBuilder clb) {
        var hostileMethod = new Consumer<MethodBuilder>() {
            @Override
            public void accept(MethodBuilder mb) {
                ConstantPoolBuilder cp = mb.constantPool();
                ClassEntry nseCE = cp.classEntry(SerializationSupport.CD_NotSerializableException);
                mb.with(ExceptionsAttribute.of(nseCE))
                        .withCode(new Consumer<CodeBuilder>() {
                            @Override
                            public void accept(CodeBuilder cob) {
                                cob.new_(nseCE)
                                        .dup()
                                        .ldc("Non-serializable lambda")
                                        .invokespecial(cp.methodRefEntry(nseCE, cp.nameAndTypeEntry(INIT_NAME,
                                                SerializationSupport.MTD_CTOR_NOT_SERIALIZABLE_EXCEPTION)))
                                        .athrow();
                            }
                        });
            }
        };
        clb.withMethod(SerializationSupport.NAME_METHOD_WRITE_OBJECT, SerializationSupport.MTD_void_ObjectOutputStream,
                ACC_PRIVATE + ACC_FINAL, hostileMethod);
        clb.withMethod(SerializationSupport.NAME_METHOD_READ_OBJECT, SerializationSupport.MTD_void_ObjectInputStream,
                ACC_PRIVATE + ACC_FINAL, hostileMethod);
    }

    /**
     * This method generates a method body which calls the lambda implementation
     * method, converting arguments, as needed.
     */
    Consumer<CodeBuilder> forwardingMethod(MethodType methodType) {
        return new Consumer<>() {
            @Override
            public void accept(CodeBuilder cob) {
                if (implKind == MethodHandleInfo.REF_newInvokeSpecial) {
                    cob.new_(implMethodClassDesc)
                       .dup();
                }
                if (useImplMethodHandle) {
                    ConstantPoolBuilder cp = cob.constantPool();
                    cob.ldc(cp.constantDynamicEntry(cp.bsmEntry(cp.methodHandleEntry(BSM_CLASS_DATA), List.of()),
                                                    cp.nameAndTypeEntry(DEFAULT_NAME, CD_MethodHandle)));
                }
                for (int i = 0; i < argDescs.length; i++) {
                    cob.aload(0)
                       .getfield(pool.fieldRefEntry(lambdaClassEntry, pool.nameAndTypeEntry(argName(i), argDescs[i])));
                }

                convertArgumentTypes(cob, methodType);

                if (useImplMethodHandle) {
                    MethodType mtype = implInfo.getMethodType();
                    if (implKind != MethodHandleInfo.REF_invokeStatic) {
                        mtype = mtype.insertParameterTypes(0, implClass);
                    }
                    cob.invokevirtual(CD_MethodHandle, "invokeExact", methodDesc(mtype));
                } else {
                    // Invoke the method we want to forward to
                    cob.invoke(invocationOpcode(), implMethodClassDesc, implMethodName, implMethodDesc, implClass.isInterface());
                }
                // Convert the return value (if any) and return it
                // Note: if adapting from non-void to void, the 'return'
                // instruction will pop the unneeded result
                Class<?> implReturnClass = implMethodType.returnType();
                Class<?> samReturnClass = methodType.returnType();
                TypeConvertingMethodAdapter.convertType(cob, implReturnClass, samReturnClass, samReturnClass);
                cob.return_(TypeKind.from(samReturnClass));
            }
        };
    }

    private void convertArgumentTypes(CodeBuilder cob, MethodType samType) {
        int samParametersLength = samType.parameterCount();
        int captureArity = factoryType.parameterCount();
        for (int i = 0; i < samParametersLength; i++) {
            Class<?> argType = samType.parameterType(i);
            cob.loadLocal(TypeKind.from(argType), cob.parameterSlot(i));
            TypeConvertingMethodAdapter.convertType(cob, argType, implMethodType.parameterType(captureArity + i), dynamicMethodType.parameterType(i));
        }
    }

    private Opcode invocationOpcode() throws InternalError {
        return switch (implKind) {
            case MethodHandleInfo.REF_invokeStatic     -> Opcode.INVOKESTATIC;
            case MethodHandleInfo.REF_newInvokeSpecial -> Opcode.INVOKESPECIAL;
            case MethodHandleInfo.REF_invokeVirtual    -> Opcode.INVOKEVIRTUAL;
            case MethodHandleInfo.REF_invokeInterface  -> Opcode.INVOKEINTERFACE;
            case MethodHandleInfo.REF_invokeSpecial    -> Opcode.INVOKESPECIAL;
            default -> throw new InternalError("Unexpected invocation kind: " + implKind);
        };
    }

    static ClassDesc implClassDesc(Class<?> cls) {
        return cls.isHidden() ? null : ConstantUtils.referenceClassDesc(cls.descriptorString());
    }

    static ClassDesc classDesc(Class<?> cls) {
        return cls.isPrimitive() ? Wrapper.forPrimitiveType(cls).basicClassDescriptor()
                                 : ConstantUtils.referenceClassDesc(cls.descriptorString());
    }

    static MethodTypeDesc methodDesc(MethodType mt) {
        var params = new ClassDesc[mt.parameterCount()];
        for (int i = 0; i < params.length; i++) {
            params[i] = classDesc(mt.parameterType(i));
        }
        return MethodTypeDescImpl.ofValidated(classDesc(mt.returnType()), params);
    }
}