8294960: Convert java.base/java.lang.invoke package to use the Classfile API to generate lambdas and method handles

src/java.base/share/classes/java/lang/classfile/constantpool/ConstantPoolBuilder.java

@@ -40,10 +40,13 @@
 import java.lang.constant.ModuleDesc;
 import java.lang.constant.PackageDesc;
 import java.lang.classfile.WritableElement;
+import jdk.internal.classfile.impl.AbstractPoolEntry.ClassEntryImpl;
 import jdk.internal.classfile.impl.AbstractPoolEntry.NameAndTypeEntryImpl;
 import jdk.internal.classfile.impl.SplitConstantPool;
 import jdk.internal.classfile.impl.TemporaryConstantPool;
+import jdk.internal.classfile.impl.Util;
 import jdk.internal.javac.PreviewFeature;
+import static java.util.Objects.requireNonNull;
 
 /**
  * Builder for the constant pool of a classfile.  Provides read and write access
@@ -151,7 +154,14 @@ default Utf8Entry utf8Entry(MethodTypeDesc desc) {
      * @param classDesc the symbolic descriptor for the class
      * @throws IllegalArgumentException if {@code classDesc} represents a primitive type
      */
-    ClassEntry classEntry(ClassDesc classDesc);
+    default ClassEntry classEntry(ClassDesc classDesc) {
+        if (requireNonNull(classDesc).isPrimitive()) {
+            throw new IllegalArgumentException("Cannot be encoded as ClassEntry: " + classDesc.displayName());
+        }
+        ClassEntryImpl ret = (ClassEntryImpl)classEntry(utf8Entry(classDesc.isArray() ? classDesc.descriptorString() : Util.toInternalName(classDesc)));
+        ret.sym = classDesc;
+        return ret;
+    }
 
     /**
      * {@return A {@link PackageEntry} describing the class whose internal name

src/java.base/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java

@@ -170,7 +170,7 @@ public InnerClassLambdaMetafactory(MethodHandles.Lookup caller,
         super(caller, factoryType, interfaceMethodName, interfaceMethodType,
               implementation, dynamicMethodType,
               isSerializable, altInterfaces, altMethods);
-        implMethodClassDesc = classDesc(implClass);
+        implMethodClassDesc = implClassDesc(implClass);
         implMethodName = implInfo.getName();
         implMethodDesc = methodDesc(implInfo.getMethodType());
         constructorType = factoryType.changeReturnType(Void.TYPE);
@@ -543,9 +543,13 @@ private Opcode invocationOpcode() throws InternalError {
         };
     }
 
-    static ClassDesc classDesc(Class<?> cls) {
+    static ClassDesc implClassDesc(Class<?> cls) {
         return cls.isHidden() ? ClassDesc.ofInternalName(cls.getName().replace('.', '/'))
-                              : ClassDesc.ofDescriptor(cls.descriptorString());
+                              : classDesc(cls);
+    }
+
+    static ClassDesc classDesc(Class<?> cls) {
+        return ClassDesc.ofDescriptor(cls.descriptorString());
     }
 
     static MethodTypeDesc methodDesc(MethodType mt) {

src/java.base/share/classes/java/lang/invoke/InvokerBytecodeGenerator.java

@@ -356,6 +356,14 @@ public void accept(CodeBuilder cob) {
         });
     }
 
+    private void emitLoadInsn(CodeBuilder cob, TypeKind type, int index) {
+        cob.loadInstruction(type, localsMap[index]);
+    }
+
+    private void emitStoreInsn(CodeBuilder cob, TypeKind type, int index) {
+        cob.storeInstruction(type, localsMap[index]);
+    }
+
     /**
      * Emit a boxing call.
      *
@@ -446,8 +454,8 @@ else if (PROFILE_LEVEL > 0)
                 cob.checkcast(CE_Object);
         }
         if (writeBack != null) {
-            cob.dup()
-               .astore(localsMap[writeBack.index()]);
+            cob.dup();
+            emitStoreInsn(cob, TypeKind.ReferenceType, writeBack.index());
         }
     }
 
@@ -908,7 +916,7 @@ private Name emitSelectAlternative(CodeBuilder cob, Name selectAlternativeName,
         // invoke selectAlternativeName.arguments[1]
         Class<?>[] preForkClasses = localClasses.clone();
         emitPushArgument(cob, selectAlternativeName, 1);  // get 2nd argument of selectAlternative
-        cob.astore(localsMap[receiver.index()]);  // store the MH in the receiver slot
+        emitStoreInsn(cob, TypeKind.ReferenceType, receiver.index());  // store the MH in the receiver slot
         emitStaticInvoke(cob, invokeBasicName);
 
         // goto L_done
@@ -920,7 +928,7 @@ private Name emitSelectAlternative(CodeBuilder cob, Name selectAlternativeName,
         // invoke selectAlternativeName.arguments[2]
         System.arraycopy(preForkClasses, 0, localClasses, 0, preForkClasses.length);
         emitPushArgument(cob, selectAlternativeName, 2);  // get 3rd argument of selectAlternative
-        cob.astore(localsMap[receiver.index()]);  // store the MH in the receiver slot
+        emitStoreInsn(cob, TypeKind.ReferenceType, receiver.index());  // store the MH in the receiver slot
         emitStaticInvoke(cob, invokeBasicName);
 
         // L_done:
@@ -1102,12 +1110,12 @@ private Name emitTryFinally(CodeBuilder cob, int pos) {
         // FINALLY_NORMAL:
         int index = extendLocalsMap(new Class<?>[]{ returnType });
         if (isNonVoid) {
-            cob.storeInstruction(basicReturnType.basicTypeKind(), localsMap[index]);
+            emitStoreInsn(cob, basicReturnType.basicTypeKind(), index);
         }
         emitPushArgument(cob, invoker, 1); // load cleanup
         cob.constantInstruction(null);
         if (isNonVoid) {
-            cob.loadInstruction(basicReturnType.basicTypeKind(), localsMap[index]);
+            emitLoadInsn(cob, basicReturnType.basicTypeKind(), index);
         }
         emitPushArguments(cob, args, 1); // load args (skip 0: method handle)
         cob.invokevirtual(CD_MethodHandle, "invokeBasic", cleanupDesc);
@@ -1141,17 +1149,11 @@ private void emitPopInsn(CodeBuilder cob, BasicType type) {
     }
 
     private static Opcode popInsnOpcode(BasicType type) {
-        switch (type) {
-            case I_TYPE:
-            case F_TYPE:
-            case L_TYPE:
-                return Opcode.POP;
-            case J_TYPE:
-            case D_TYPE:
-                return Opcode.POP2;
-            default:
-                throw new InternalError("unknown type: " + type);
-        }
+        return switch (type) {
+            case I_TYPE, F_TYPE, L_TYPE -> Opcode.POP;
+            case J_TYPE, D_TYPE -> Opcode.POP2;
+            default -> throw new InternalError("unknown type: " + type);
+        };
     }
 
     private Name emitTableSwitch(CodeBuilder cob, int pos, int numCases) {
@@ -1169,7 +1171,7 @@ private Name emitTableSwitch(CodeBuilder cob, int pos, int numCases) {
         cob.getfield(ClassDesc.ofInternalName("java/lang/invoke/MethodHandleImpl$CasesHolder"), "cases",
                 CD_MethodHandle.arrayType());
         int casesLocal = extendLocalsMap(new Class<?>[] { MethodHandle[].class });
-        cob.astore(localsMap[casesLocal]);
+        emitStoreInsn(cob, TypeKind.ReferenceType, casesLocal);
 
         Label endLabel = cob.newLabel();
         Label defaultLabel = cob.newLabel();
@@ -1190,7 +1192,7 @@ private Name emitTableSwitch(CodeBuilder cob, int pos, int numCases) {
         for (int i = 0; i < numCases; i++) {
             cob.labelBinding(cases.get(i).target());
             // Load the particular case:
-            cob.aload(localsMap[casesLocal]);
+            emitLoadInsn(cob, TypeKind.ReferenceType, casesLocal);
             cob.constantInstruction(i);
             cob.aaload();
 
@@ -1329,15 +1331,15 @@ private Name emitLoop(CodeBuilder cob, int pos) {
         // PREINIT:
         emitPushArgument(cob, MethodHandleImpl.LoopClauses.class, invoker.arguments[1]);
         cob.getfield(CD_LOOP_CLAUSES, "clauses", CD_MHARY2);
-        cob.astore(localsMap[clauseDataIndex]);
+        emitStoreInsn(cob, TypeKind.ReferenceType, clauseDataIndex);
 
         // INIT:
         for (int c = 0, state = 0; c < nClauses; ++c) {
             MethodType cInitType = loopType.changeReturnType(loopClauseTypes[c].basicTypeClass());
             emitLoopHandleInvoke(cob, invoker, inits, c, args, false, cInitType, loopLocalStateTypes, clauseDataIndex,
                     firstLoopStateIndex);
             if (cInitType.returnType() != void.class) {
-                cob.storeInstruction(BasicType.basicType(cInitType.returnType()).basicTypeKind(), localsMap[firstLoopStateIndex + state]);
+                emitStoreInsn(cob, BasicType.basicType(cInitType.returnType()).basicTypeKind(), firstLoopStateIndex + state);
                 ++state;
             }
         }
@@ -1355,7 +1357,7 @@ private Name emitLoop(CodeBuilder cob, int pos) {
             emitLoopHandleInvoke(cob, invoker, steps, c, args, true, stepType, loopLocalStateTypes, clauseDataIndex,
                     firstLoopStateIndex);
             if (!isVoid) {
-                cob.storeInstruction(BasicType.basicType(stepType.returnType()).basicTypeKind(), localsMap[firstLoopStateIndex + state]);
+                emitStoreInsn(cob, BasicType.basicType(stepType.returnType()).basicTypeKind(), firstLoopStateIndex + state);
                 ++state;
             }
 
@@ -1407,7 +1409,7 @@ private void emitLoopHandleInvoke(CodeBuilder cob, Name holder, int handles, int
         // load loop state (preceding the other arguments)
         if (pushLocalState) {
             for (int s = 0; s < loopLocalStateTypes.length; ++s) {
-                cob.loadInstruction(BasicType.basicType(loopLocalStateTypes[s]).basicTypeKind(), localsMap[firstLoopStateSlot + s]);
+                emitLoadInsn(cob, BasicType.basicType(loopLocalStateTypes[s]).basicTypeKind(), firstLoopStateSlot + s);
             }
         }
         // load loop args (skip 0: method handle)
@@ -1416,7 +1418,7 @@ private void emitLoopHandleInvoke(CodeBuilder cob, Name holder, int handles, int
     }
 
     private void emitPushClauseArray(CodeBuilder cob, int clauseDataSlot, int which) {
-        cob.aload(localsMap[clauseDataSlot]);
+        emitLoadInsn(cob, TypeKind.ReferenceType, clauseDataSlot);
         cob.constantInstruction(which - 1);
         cob.aaload();
     }
@@ -1448,7 +1450,7 @@ private void emitPushArgument(CodeBuilder cob, Name name, int paramIndex) {
     private void emitPushArgument(CodeBuilder cob, Class<?> ptype, Object arg) {
         BasicType bptype = basicType(ptype);
         if (arg instanceof Name n) {
-            cob.loadInstruction(n.type.basicTypeKind(), localsMap[n.index()]);
+            emitLoadInsn(cob, n.type.basicTypeKind(), n.index());
             emitImplicitConversion(cob, n.type, ptype, n);
         } else if ((arg == null || arg instanceof String) && bptype == L_TYPE) {
             cob.constantInstruction((ConstantDesc)arg);
@@ -1468,7 +1470,7 @@ private void emitPushArgument(CodeBuilder cob, Class<?> ptype, Object arg) {
     private void emitStoreResult(CodeBuilder cob, Name name) {
         if (name != null && name.type != V_TYPE) {
             // non-void: actually assign
-            cob.storeInstruction(name.type.basicTypeKind(), localsMap[name.index()]);
+            emitStoreInsn(cob, name.type.basicTypeKind(), name.index());
         }
     }
 
@@ -1489,7 +1491,7 @@ private void emitReturn(CodeBuilder cob, Name onStack) {
 
             // put return value on the stack if it is not already there
             if (rn != onStack) {
-                cob.loadInstruction(rtype.basicTypeKind(), localsMap[lambdaForm.result]);
+                emitLoadInsn(cob, rtype.basicTypeKind(), lambdaForm.result);
             }
 
             emitImplicitConversion(cob, rtype, rclass, rn);
@@ -1515,8 +1517,17 @@ private void emitPrimCast(CodeBuilder cob, TypeKind from, TypeKind to) {
         //      long        -     l2i,i2b   l2i,i2s  l2i,i2c    l2i      <->      l2f      l2d
         //      float       -     f2i,i2b   f2i,i2s  f2i,i2c    f2i      f2l      <->      f2d
         //      double      -     d2i,i2b   d2i,i2s  d2i,i2c    d2i      d2l      d2f      <->
-        if (from != to && from != TypeKind.BooleanType && to != TypeKind.BooleanType) try {
-            cob.convertInstruction(from, to);
+        if (from != to && from != TypeKind.BooleanType) try {
+            switch (to) {
+                case IntType, LongType, FloatType, DoubleType ->
+                    cob.convertInstruction(from, to);
+                case ByteType, ShortType, CharType -> {
+                    if (from != TypeKind.IntType) {
+                        cob.convertInstruction(from, TypeKind.IntType);
+                    }
+                    cob.convertInstruction(TypeKind.IntType, to);
+                }
+            }
         } catch (IllegalArgumentException e) {
             throw new IllegalStateException("unhandled prim cast: " + from + "2" + to);
         }
@@ -1559,7 +1570,7 @@ public void accept(CodeBuilder cob) {
                                     Class<?> ptype = invokerType.parameterType(i);
                                     cob.dup();
                                     cob.constantInstruction(i);
-                                    cob.loadInstruction(basicType(ptype).basicTypeKind(), localsMap[i]);
+                                    emitLoadInsn(cob, basicType(ptype).basicTypeKind(), i);
                                     // box if primitive type
                                     if (ptype.isPrimitive()) {
                                         emitBoxing(cob, TypeKind.from(ptype));

src/java.base/share/classes/java/lang/invoke/MethodType.java

@@ -1291,16 +1291,21 @@ static String toFieldDescriptorString(Class<?> cls) {
      */
     @Override
     public Optional<MethodTypeDesc> describeConstable() {
-        try {
-            var params = new ClassDesc[parameterCount()];
-            for (int i = 0; i < params.length; i++) {
-                params[i] = parameterType(i).describeConstable().orElseThrow();
-            }
-            return Optional.of(MethodTypeDesc.of(returnType().describeConstable().orElseThrow(), params));
-        }
-        catch (NoSuchElementException e) {
+        var retDesc = returnType().describeConstable();
+        if (retDesc.isEmpty())
             return Optional.empty();
+
+        if (parameterCount() == 0)
+            return Optional.of(MethodTypeDesc.of(retDesc.get()));
+
+        var params = new ClassDesc[parameterCount()];
+        for (int i = 0; i < params.length; i++) {
+            var paramDesc = parameterType(i).describeConstable();
+            if (paramDesc.isEmpty())
+                return Optional.empty();
+            params[i] = paramDesc.get();
         }
+        return Optional.of(MethodTypeDesc.of(retDesc.get(), params));
     }
 
     /// Serialization.

src/java.base/share/classes/java/lang/invoke/TypeConvertingMethodAdapter.java

@@ -32,6 +32,15 @@
 import java.lang.classfile.constantpool.ConstantPoolBuilder;
 import java.lang.classfile.constantpool.MethodRefEntry;
 import static java.lang.constant.ConstantDescs.*;
+import static sun.invoke.util.Wrapper.BOOLEAN;
+import static sun.invoke.util.Wrapper.BYTE;
+import static sun.invoke.util.Wrapper.CHAR;
+import static sun.invoke.util.Wrapper.DOUBLE;
+import static sun.invoke.util.Wrapper.FLOAT;
+import static sun.invoke.util.Wrapper.INT;
+import static sun.invoke.util.Wrapper.LONG;
+import static sun.invoke.util.Wrapper.SHORT;
+import static sun.invoke.util.Wrapper.VOID;
 
 class TypeConvertingMethodAdapter {
 
@@ -64,22 +73,15 @@ private static MethodRefEntry unbox(ClassDesc owner, String methodName, ClassDes
                                         UNBOX_DOUBLE  = unbox(CD_Number, "doubleValue", CD_double);
 
     static private TypeKind primitiveTypeKindFromClass(Class<?> type) {
-        return switch (type.getName().length()) {
-            case 14 -> type == Long.class ? TypeKind.LongType
-                     : type == Byte.class ? TypeKind.ByteType
-                     : null;
-            case 15 -> type == Short.class ? TypeKind.ShortType
-                     : type == Float.class ? TypeKind.FloatType
-                     : null;
-            case 16 -> type == Double.class ? TypeKind.DoubleType
-                     : null;
-            case 17 -> type == Integer.class ? TypeKind.IntType
-                     : type == Boolean.class ? TypeKind.BooleanType
-                     : null;
-            case 19 -> type == Character.class ? TypeKind.CharType
-                     : null;
-            default -> null;
-        };
+        if (type == int.class)     return TypeKind.IntType;
+        if (type == long.class)    return TypeKind.LongType;
+        if (type == boolean.class) return TypeKind.BooleanType;
+        if (type == short.class)   return TypeKind.ShortType;
+        if (type == byte.class)    return TypeKind.ByteType;
+        if (type == char.class)    return TypeKind.CharType;
+        if (type == float.class)   return TypeKind.FloatType;
+        if (type == double.class)  return TypeKind.DoubleType;
+        return null;
     }
 
     static void boxIfTypePrimitive(CodeBuilder cob, TypeKind tk) {

src/java.base/share/classes/jdk/internal/classfile/impl/SplitConstantPool.java

@@ -55,9 +55,6 @@
 import static java.lang.classfile.ClassFile.TAG_NAMEANDTYPE;
 import static java.lang.classfile.ClassFile.TAG_PACKAGE;
 import static java.lang.classfile.ClassFile.TAG_STRING;
-import java.lang.constant.ClassDesc;
-import java.lang.constant.ConstantDescs;
-import static java.util.Objects.requireNonNull;
 
 public final class SplitConstantPool implements ConstantPoolBuilder {
 
@@ -70,7 +67,6 @@ public final class SplitConstantPool implements ConstantPoolBuilder {
     private boolean doneFullScan;
     private EntryMap<PoolEntry> map;
     private EntryMap<BootstrapMethodEntryImpl> bsmMap;
-    private ClassEntry objectEntry;
 
     public SplitConstantPool() {
         this.size = 1;
@@ -374,26 +370,6 @@ public AbstractPoolEntry.ClassEntryImpl classEntry(Utf8Entry nameEntry) {
         return e == null ? internalAdd(new AbstractPoolEntry.ClassEntryImpl(this, size, ne)) : e;
     }
 
-    @Override
-    public ClassEntry classEntry(ClassDesc classDesc) {
-        if (classDesc == ConstantDescs.CD_Object) {
-            if (objectEntry == null) {
-                objectEntry = _classEntry(classDesc);
-            }
-            return objectEntry;
-        }
-        if (requireNonNull(classDesc).isPrimitive()) {
-            throw new IllegalArgumentException("Cannot be encoded as ClassEntry: " + classDesc.displayName());
-        }
-        return _classEntry(classDesc);
-    }
-
-    private ClassEntry _classEntry(ClassDesc classDesc) {
-        var ret = classEntry(utf8Entry(classDesc.isArray() ? classDesc.descriptorString() : Util.toInternalName(classDesc)));
-        ret.sym = classDesc;
-        return ret;
-    }
-
     @Override
     public PackageEntry packageEntry(Utf8Entry nameEntry) {
         AbstractPoolEntry.Utf8EntryImpl ne = maybeCloneUtf8Entry(nameEntry);

src/java.base/share/classes/jdk/internal/classfile/impl/TemporaryConstantPool.java

@@ -47,11 +47,9 @@
 import java.lang.classfile.constantpool.PoolEntry;
 import java.lang.classfile.constantpool.StringEntry;
 import java.lang.classfile.constantpool.Utf8Entry;
-import java.lang.constant.ClassDesc;
 
 import java.lang.constant.MethodTypeDesc;
 import java.util.List;
-import static java.util.Objects.requireNonNull;
 
 public final class TemporaryConstantPool implements ConstantPoolBuilder {
 
@@ -89,16 +87,6 @@ public ClassEntry classEntry(Utf8Entry name) {
         return new AbstractPoolEntry.ClassEntryImpl(this, -2, (AbstractPoolEntry.Utf8EntryImpl) name);
     }
 
-    @Override
-    public ClassEntry classEntry(ClassDesc classDesc) {
-        if (requireNonNull(classDesc).isPrimitive()) {
-            throw new IllegalArgumentException("Cannot be encoded as ClassEntry: " + classDesc.displayName());
-        }
-        var ret = (AbstractPoolEntry.ClassEntryImpl)classEntry(utf8Entry(classDesc.isArray() ? classDesc.descriptorString() : Util.toInternalName(classDesc)));
-        ret.sym = classDesc;
-        return ret;
-    }
-
     @Override
     public PackageEntry packageEntry(Utf8Entry name) {
         return new AbstractPoolEntry.PackageEntryImpl(this, -2, (AbstractPoolEntry.Utf8EntryImpl) name);