Restore CurriedFields in ClassBuilder.

Now that the CallSite table is immortal, everything added to that is a
memory leak, so we need to be judicious. Tests with many Bosk objects
having large state trees can run out of memory, which is pretty
annoying.

The downside of curried fields is that final instance fields are not
_really_ final, so they're generally slower than static finals and
ConstantCallSites, but at the moment, OOMs caused by leaks seem to be a
bigger problem (though unlikely in production, where there's only
typically a single, long-lived Bosk object).

Author: prdoyle

bosk-core/src/main/java/works/bosk/bytecode/ClassBuilder.java

@@ -4,12 +4,13 @@
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.lang.invoke.CallSite;
-import java.lang.invoke.ConstantCallSite;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
@@ -31,13 +32,16 @@
 import static java.lang.System.identityHashCode;
 import static java.lang.reflect.Modifier.isStatic;
 import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.joining;
 import static org.objectweb.asm.ClassWriter.COMPUTE_FRAMES;
 import static org.objectweb.asm.Opcodes.ACC_FINAL;
+import static org.objectweb.asm.Opcodes.ACC_PRIVATE;
 import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
 import static org.objectweb.asm.Opcodes.ACC_SUPER;
 import static org.objectweb.asm.Opcodes.ALOAD;
 import static org.objectweb.asm.Opcodes.CHECKCAST;
 import static org.objectweb.asm.Opcodes.DUP;
+import static org.objectweb.asm.Opcodes.GETFIELD;
 import static org.objectweb.asm.Opcodes.H_INVOKESTATIC;
 import static org.objectweb.asm.Opcodes.IFEQ;
 import static org.objectweb.asm.Opcodes.IFNE;
@@ -49,6 +53,7 @@
 import static org.objectweb.asm.Opcodes.ISTORE;
 import static org.objectweb.asm.Opcodes.NEW;
 import static org.objectweb.asm.Opcodes.POP;
+import static org.objectweb.asm.Opcodes.PUTFIELD;
 import static org.objectweb.asm.Opcodes.RETURN;
 import static org.objectweb.asm.Opcodes.SWAP;
 import static org.objectweb.asm.Opcodes.V1_8;
@@ -72,6 +77,8 @@ public final class ClassBuilder<T> {
 	private MethodBuilder currentMethod = null;
 	private int currentLineNumber = -1;
 
+	private final List<CurriedField> curriedFields = new ArrayList<>();
+
 	/**
 	 * @param className The simple name of the generated class;
 	 * 		the actual name will be given the prefix <code>GENERATED_</code> to identify it as not corresponding to any source file
@@ -110,13 +117,21 @@ public void beginClass() {
 	}
 
 	private void generateConstructor(StackWalker.StackFrame sourceFileOrigin) {
-		MethodVisitor ctor = classVisitor.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
+		String ctorParameterDescriptor = curriedFields.stream()
+			.map(CurriedField::typeDescriptor)
+			.collect(joining());
+		MethodVisitor ctor = classVisitor.visitMethod(ACC_PUBLIC, "<init>", "(" + ctorParameterDescriptor + ")V", null, null);
 		ctor.visitCode();
 		Label label = new Label();
 		ctor.visitLabel(label);
 		ctor.visitLineNumber(sourceFileOrigin.getLineNumber(), label);
 		ctor.visitVarInsn(ALOAD, 0);
 		ctor.visitMethodInsn(INVOKESPECIAL, superClassName, "<init>", "()V", false);
+		for (CurriedField field: curriedFields) {
+			ctor.visitVarInsn(ALOAD, 0);
+			ctor.visitVarInsn(ALOAD, field.slot());
+			ctor.visitFieldInsn(PUTFIELD, slashyName, field.name(), field.typeDescriptor());
+		}
 		ctor.visitInsn(RETURN);
 		ctor.visitMaxs(0, 0); // Computed automatically
 		ctor.visitEnd();
@@ -196,10 +211,36 @@ public LocalVariable popToLocal(Type type) {
 	 *             be accessible from the generated class)
 	 */
 	public void pushObject(String name, Object object, Class<?> type) {
+		CurriedField field = curry(name, object, type);
+		beginPush();
+		methodVisitor().visitVarInsn(ALOAD, 0);
+		methodVisitor().visitFieldInsn(GETFIELD, slashyName, field.name(), field.typeDescriptor());
+	}
+
+	private CurriedField curry(String name, Object object, Class<?> type) {
 		type.cast(object);
+		for (CurriedField candidate: curriedFields) {
+			if (candidate.value() == object) {
+				return candidate;
+			}
+		}
 
-		// TODO: Use ConstantDynamic instead
-		invokeDynamic(name, new ConstantCallSite(MethodHandles.constant(type, object)));
+		int ctorParameterSlot = 1 + curriedFields.size();
+		CurriedField result = new CurriedField(
+			ctorParameterSlot,
+			"CURRIED" + ctorParameterSlot + "_" + name,
+			Type.getDescriptor(type),
+			object);
+		curriedFields.add(result);
+
+		classVisitor.visitField(
+			ACC_PRIVATE | ACC_FINAL,
+			result.name(),
+			result.typeDescriptor(),
+			null, null
+		).visitEnd();
+
+		return result;
 	}
 
 	public void invokeDynamic(String name, CallSite callSite) {
@@ -341,8 +382,9 @@ public T buildInstance() {
 		Constructor<?> ctor = new CustomClassLoader()
 			.loadThemBytes(dottyName, bytes)
 			.getConstructors()[0];
+		Object[] args = curriedFields.stream().map(CurriedField::value).toArray();
 		try {
-			return supertype.cast(ctor.newInstance());
+			return supertype.cast(ctor.newInstance(args));
 		} catch (InstantiationException | IllegalAccessException | VerifyError | InvocationTargetException e) {
 			throw new AssertionError("Should be able to instantiate the generated class", e);
 		}

bosk-core/src/main/java/works/bosk/bytecode/CurriedField.java

@@ -0,0 +1,15 @@
+package works.bosk.bytecode;
+
+/**
+ * An object reference that should be passed to the constructor of a generated
+ * class so that it can be referenced from method bodies via
+ * {@link org.objectweb.asm.Opcodes#GETFIELD GETFIELD}.
+ *
+ * @param slot The parameter slot in which this will arrive in the constructor
+ */
+public record CurriedField(
+	int slot,
+	String name,
+	String typeDescriptor,
+	Object value
+) { }