Add ClassTransformer.injectSuperclass

core/src/main/kotlin/org/sourcegrade/jagr/core/transformer/ClassTransformerFactoryImpl.kt

@@ -22,7 +22,10 @@ package org.sourcegrade.jagr.core.transformer
 import org.sourcegrade.jagr.api.testing.ClassTransformer
 
 class ClassTransformerFactoryImpl : ClassTransformer.Factory {
-    override fun replacement(replacement: Class<*>, original: Class<*>): ClassTransformer {
-        return ReplacementTransformer(replacement.kotlin, original.kotlin)
-    }
+
+    override fun injectSuperclass(targetName: String, superName: String): ClassTransformer =
+        InjectSuperclassTransformer(targetName, superName)
+
+    override fun replacement(replacement: Class<*>, original: Class<*>): ClassTransformer =
+        ReplacementTransformer(replacement.kotlin, original.kotlin)
 }

core/src/main/kotlin/org/sourcegrade/jagr/core/transformer/InjectSuperclassTransformer.kt

@@ -0,0 +1,83 @@
+package org.sourcegrade.jagr.core.transformer
+
+import org.objectweb.asm.ClassReader
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.ClassWriter
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+import org.sourcegrade.jagr.api.testing.ClassTransformer
+
+class InjectSuperclassTransformer(
+    targetName: String,
+    superName: String,
+) : ClassTransformer {
+    // normalize names
+    private val targetName = targetName.replace('.', '/')
+    private val superName = superName.replace('.', '/')
+    private val name = "$targetName-new-super-$superName"
+    override fun getName(): String = name
+
+    override fun transform(reader: ClassReader, writer: ClassWriter) {
+        if (reader.className == targetName) {
+            reader.accept(InjectingCV(writer), 0)
+        } else {
+            reader.accept(writer, 0)
+        }
+    }
+
+    private inner class InjectingCV(classVisitor: ClassVisitor?) : ClassVisitor(Opcodes.ASM9, classVisitor) {
+        lateinit var oldSuperName: String
+        override fun visit(
+            version: Int,
+            access: Int,
+            name: String,
+            signature: String?,
+            superName: String,
+            interfaces: Array<String>,
+        ) {
+            oldSuperName = superName
+            super.visit(version, access, name, signature, this@InjectSuperclassTransformer.superName, interfaces)
+        }
+
+        override fun visitMethod(
+            access: Int,
+            name: String,
+            descriptor: String?,
+            signature: String?,
+            exceptions: Array<out String>?,
+        ): MethodVisitor = InjectingMV(name, super.visitMethod(access, name, descriptor, signature, exceptions))
+
+        private inner class InjectingMV(
+            private val methodName: String,
+            methodVisitor: MethodVisitor?,
+        ) : MethodVisitor(Opcodes.ASM9, methodVisitor) {
+
+            private var visitedSuperConstructor = false
+
+            /**
+             * Checks if the insn is a super() call in the constructor of the target class
+             */
+            private fun isSuperInsn(opcode: Int, owner: String, name: String): Boolean {
+                val result = !visitedSuperConstructor &&
+                    opcode == Opcodes.INVOKESPECIAL &&
+                    methodName == "<init>" &&
+                    name == "<init>" &&
+                    owner == oldSuperName
+                if (result) {
+                    visitedSuperConstructor = true
+                }
+                return result
+            }
+
+            override fun visitMethodInsn(opcode: Int, owner: String, name: String, descriptor: String?, isInterface: Boolean) {
+                if ((owner == oldSuperName && opcode == Opcodes.INVOKESPECIAL && name != "<init>") ||
+                    isSuperInsn(opcode, owner, name)
+                ) {
+                    super.visitMethodInsn(opcode, superName, name, descriptor, isInterface)
+                } else {
+                    super.visitMethodInsn(opcode, owner, name, descriptor, isInterface)
+                }
+            }
+        }
+    }
+}

grader-api/src/main/java/org/sourcegrade/jagr/api/testing/ClassTransformer.java

@@ -33,6 +33,21 @@
  */
 public interface ClassTransformer {
 
+    /**
+     * Transforms the given target class so that it directly extends the provided new superclass.
+     *
+     * <p>
+     * The new superclass should extend the old superclass of the target class.
+     * </p>
+     *
+     * @param targetName The class to transform
+     * @param superName  The new superclass
+     * @return The transformer
+     */
+    static ClassTransformer injectSuperclass(String targetName, String superName) {
+        return FactoryProvider.factory.injectSuperclass(targetName, superName);
+    }
+
     /**
      * Creates a transformer that replaces all method invocations and field accesses targeting {@code original} with
      * invocations and accesses targeting {@code replacement}.
@@ -78,6 +93,8 @@ final class FactoryProvider {
 
     @ApiStatus.Internal
     interface Factory {
+        ClassTransformer injectSuperclass(String targetName, String superName);
+
         ClassTransformer replacement(Class<?> replacement, Class<?> original);
     }
 }