Support storing the code that builds the code model

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

@@ -442,14 +442,21 @@ private void generateQuotedFieldInitializer(CodeBuilder cob) {
         NameAndTypeEntry natMH = cp.nameAndTypeEntry(DEFAULT_NAME, CD_MethodHandle);
         // push the receiver on the stack for operand of put field instruction
         cob.aload(0)
+        // load class data: CodeReflectionSupport.HANDLE_MAKE_QUOTED and quotableOpGetter
            .ldc(cp.constantDynamicEntry(cp.bsmEntry(bsmDataAt, List.of(cp.intEntry(2))), natMH))
-        // load op string from field
            .ldc(cp.constantDynamicEntry(cp.bsmEntry(bsmDataAt, List.of(cp.intEntry(1))), natMH));
         MethodType mtype = quotableOpGetterInfo.getMethodType();
         if (quotableOpGetterInfo.getReferenceKind() != MethodHandleInfo.REF_invokeStatic) {
             mtype = mtype.insertParameterTypes(0, implClass);
         }
+        // load arguments to quotableOpGetter: ExtendedOp.FACTORY and CORE_TYPE_FACTORY
+        cob.fieldAccess(Opcode.GETSTATIC, CodeReflectionSupport.EXTENDED_OP_CLASS.describeConstable().get(),
+                "FACTORY", CodeReflectionSupport.OP_FACTORY_CLASS.describeConstable().get());
+        cob.fieldAccess(Opcode.GETSTATIC, CodeReflectionSupport.CORE_TYPE_FACTORY_CLASS.describeConstable().get(),
+                "CORE_TYPE_FACTORY",
+                CodeReflectionSupport.TYPE_ELEMENT_FACTORY_CLASS.describeConstable().get());
         cob.invokevirtual(CD_MethodHandle, "invokeExact", mtype.describeConstable().get());
+        cob.checkcast(CodeReflectionSupport.FUNC_OP_CLASS.describeConstable().get());
 
         // load captured args in array
 
@@ -476,6 +483,11 @@ static class CodeReflectionSupport {
         static final Class<?> QUOTED_CLASS;
         static final Class<?> QUOTABLE_CLASS;
         static final MethodHandle HANDLE_MAKE_QUOTED;
+        static final Class<?> EXTENDED_OP_CLASS;
+        static final Class<?> OP_FACTORY_CLASS;
+        static final Class<?> CORE_TYPE_FACTORY_CLASS;
+        static final Class<?> TYPE_ELEMENT_FACTORY_CLASS;
+        static final Class<?> FUNC_OP_CLASS;
 
         static {
             try {
@@ -484,10 +496,14 @@ static class CodeReflectionSupport {
                 QUOTED_CLASS = cl.loadClass("jdk.incubator.code.Quoted");
                 QUOTABLE_CLASS = cl.loadClass("jdk.incubator.code.Quotable");
                 Class<?> quotedHelper = cl.loadClass("jdk.incubator.code.internal.QuotedHelper");
-                Class<?> funcOp = cl.loadClass("jdk.incubator.code.op.CoreOp$FuncOp");
+                FUNC_OP_CLASS = cl.loadClass("jdk.incubator.code.op.CoreOp$FuncOp");
                 MethodHandle makeQuoted = Lookup.IMPL_LOOKUP.findStatic(quotedHelper, "makeQuoted",
-                        MethodType.methodType(QUOTED_CLASS, MethodHandles.Lookup.class, funcOp, Object[].class));
+                        MethodType.methodType(QUOTED_CLASS, MethodHandles.Lookup.class, FUNC_OP_CLASS, Object[].class));
                 HANDLE_MAKE_QUOTED = makeQuoted.bindTo(Lookup.IMPL_LOOKUP);
+                EXTENDED_OP_CLASS = cl.loadClass("jdk.incubator.code.op.ExtendedOp");
+                OP_FACTORY_CLASS = cl.loadClass("jdk.incubator.code.op.OpFactory");
+                CORE_TYPE_FACTORY_CLASS = cl.loadClass("jdk.incubator.code.type.CoreTypeFactory");
+                TYPE_ELEMENT_FACTORY_CLASS = cl.loadClass("jdk.incubator.code.type.TypeElementFactory");
             } catch (Throwable ex) {
                 throw new ExceptionInInitializerError(ex);
             }

src/jdk.incubator.code/share/classes/jdk/incubator/code/Op.java

@@ -40,8 +40,12 @@
 import com.sun.tools.javac.util.Context;
 import jdk.incubator.code.internal.ReflectMethods;
 import jdk.incubator.code.op.CoreOp.FuncOp;
+import jdk.incubator.code.op.ExtendedOp;
+import jdk.incubator.code.op.OpFactory;
+import jdk.incubator.code.type.CoreTypeFactory;
 import jdk.incubator.code.type.FunctionType;
 import jdk.incubator.code.type.MethodRef;
+import jdk.incubator.code.type.TypeElementFactory;
 import jdk.incubator.code.writer.OpWriter;
 import jdk.internal.access.SharedSecrets;
 
@@ -526,17 +530,18 @@ private static Optional<FuncOp> createCodeModel(Method method) {
                 case '.', ';', '[', '/': sig[i] = '$';
             }
         }
-        String opMethodName = "op$" + new String(sig);
+        String opMethodName = new String(sig);
         Method opMethod;
         try {
             // @@@ Use method handle with full power mode
-            opMethod = method.getDeclaringClass().getDeclaredMethod(opMethodName);
+            opMethod = method.getDeclaringClass().getDeclaredMethod(opMethodName, OpFactory.class,
+                    TypeElementFactory.class);
         } catch (NoSuchMethodException e) {
             return Optional.empty();
         }
         opMethod.setAccessible(true);
         try {
-            FuncOp funcOp = (FuncOp) opMethod.invoke(null);
+            FuncOp funcOp = (FuncOp) opMethod.invoke(null, ExtendedOp.FACTORY, CoreTypeFactory.CORE_TYPE_FACTORY);
             return Optional.of(funcOp);
         } catch (ReflectiveOperationException e) {
             throw new RuntimeException(e);

src/jdk.incubator.code/share/classes/jdk/incubator/code/bytecode/BytecodeGenerator.java

@@ -54,13 +54,15 @@
 import jdk.incubator.code.Value;
 import jdk.incubator.code.op.CoreOp;
 import jdk.incubator.code.op.CoreOp.*;
+import jdk.incubator.code.op.OpFactory;
 import jdk.incubator.code.parser.OpParser;
 import jdk.incubator.code.type.ArrayType;
 import jdk.incubator.code.type.FieldRef;
 import jdk.incubator.code.type.FunctionType;
 import jdk.incubator.code.type.JavaType;
 import jdk.incubator.code.type.MethodRef;
 import jdk.incubator.code.type.PrimitiveType;
+import jdk.incubator.code.type.TypeElementFactory;
 import jdk.incubator.code.type.VarType;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -92,6 +94,8 @@ public final class BytecodeGenerator {
             StringConcatFactory.class.describeConstable().orElseThrow(),
             "makeConcat",
             CD_CallSite);
+    private static final MethodTypeDesc opMethodDesc = MethodTypeDesc.of(FuncOp.class.describeConstable().get(),
+            OpFactory.class.describeConstable().get(), TypeElementFactory.class.describeConstable().get());
 
     /**
      * Transforms the invokable operation to bytecode encapsulated in a method of hidden class and exposed
@@ -165,7 +169,7 @@ public static <O extends Op & Op.Invokable> byte[] generateClassData(MethodHandl
                 LambdaOp lop = lambdaSink.get(i);
                 if (quotable.get(i)) {
                     // return (FuncOp) OpParser.fromOpString(opText)
-                    clb.withMethod("op$lambda$" + i, MethodTypeDesc.of(FuncOp.class.describeConstable().get()),
+                    clb.withMethod("op$lambda$" + i, opMethodDesc,
                         ClassFile.ACC_PUBLIC | ClassFile.ACC_STATIC | ClassFile.ACC_SYNTHETIC, mb -> mb.withCode(cb -> cb
                                 .loadConstant(quote(lop).toText())
                                 .invoke(Opcode.INVOKESTATIC, OpParser.class.describeConstable().get(),
@@ -901,7 +905,7 @@ private void generate() {
                                         MethodHandleDesc.ofMethod(DirectMethodHandleDesc.Kind.STATIC,
                                                 className,
                                                 "op$lambda$" + lambdaIndex,
-                                                MethodTypeDesc.of(FuncOp.class.describeConstable().get()))));
+                                                opMethodDesc)));
                                 quotable.set(lambdaSink.size());
                             } else {
                                 cob.invokedynamic(DynamicCallSiteDesc.of(