New: Upgrade JMH test classes to Java 11.

This is needed to ensure we can test all the coverage approaches.

Author: LlamaLad7

benchmarks/build.gradle

@@ -1,3 +1,5 @@
+import com.intellij.rt.coverage.utils.ClassFileUpgradeTask
+
 /*
  * Copyright 2000-2018 JetBrains s.r.o.
  *
@@ -34,3 +36,13 @@ dependencies {
     jmhImplementation 'junit:junit:4.13.1'
     jmhImplementation fileTree('lib')
 }
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}
+
+task upgradeJmhClasspath(type: ClassFileUpgradeTask) {
+    inputFiles = sourceSets.jmh.runtimeClasspath
+    outputDirectory = layout.buildDirectory.dir("jmhClasspath").get()
+}

benchmarks/jmh.gradle

@@ -41,10 +41,11 @@ task NoAgent(type: JavaExec) {
 def configureBenchmark(JavaExec benchmark, Closure<List<String>> jvmArgs = {[]}) {
   benchmark.with {
     group = 'benchmarks'
-    dependsOn ":benchmarks:jmhClasses"
+    dependsOn(":benchmarks:jmhClasses", ":benchmarks:upgradeJmhClasspath")
     main = 'org.openjdk.jmh.Main'
     doFirst {
-      classpath = project(":benchmarks").sourceSets.jmh.runtimeClasspath
+      classpath = fileTree(project(":benchmarks").upgradeJmhClasspath.outputs.files.singleFile)
+      classpath += project(":benchmarks").sourceSets.jmh.output.classesDirs
       args = [
           '-jvmArgs', '-Dfile.encoding=UTF-8',
           // benchmarks

buildSrc/build.gradle.kts

@@ -24,4 +24,7 @@ repositories {
 
 dependencies {
     implementation("com.guardsquare:proguard-gradle:7.3.0")
+    implementation("org.ow2.asm:asm-tree:9.7")
+    implementation("org.ow2.asm:asm-commons:9.7")
+    implementation("commons-io:commons-io:2.16.1")
 }

buildSrc/src/main/groovy/com/intellij/rt/coverage/utils/ClassFileUpgradeTask.groovy

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2000-2024 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.intellij.rt.coverage.utils
+
+import groovy.transform.CompileStatic
+import org.apache.commons.io.IOUtils
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.Directory
+import org.gradle.api.file.FileCollection
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+import org.objectweb.asm.ClassReader
+
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+import java.util.zip.ZipOutputStream
+
+@CompileStatic
+abstract class ClassFileUpgradeTask extends DefaultTask {
+  @InputFiles
+  FileCollection inputFiles
+
+  @OutputDirectory
+  Directory outputDirectory
+
+  @TaskAction
+  void transform() {
+    def inputJars = inputFiles.files.findAll { it.name.endsWith(".jar") }
+    List<ZipFile> zipFiles = []
+    try {
+      inputJars.each {
+        zipFiles << new ZipFile(it)
+      }
+      process(zipFiles)
+    } finally {
+      zipFiles.each { it.close() }
+    }
+  }
+
+  private void process(List<ZipFile> zipFiles) {
+    def superClasses = collectSuperClasses(zipFiles)
+    transformJars(zipFiles, superClasses)
+  }
+
+  private Map<String, String> collectSuperClasses(List<ZipFile> zipFiles) {
+    Map<String, String> superClasses = [:]
+    zipFiles.each { zip ->
+      eachEntry(zip) { ZipEntry classEntry ->
+        if (!classEntry.name.endsWith(".class")) {
+          return
+        }
+        zip.getInputStream(classEntry).withStream { inputStream ->
+          def reader = new ClassReader(inputStream)
+          superClasses[reader.className] = reader.superName
+        }
+      }
+    }
+    return superClasses
+  }
+
+  private void transformJars(List<ZipFile> zipFiles, Map<String, String> superClasses) {
+    zipFiles.each { zip ->
+      def outputFile = outputDirectory.file(new File(zip.name).name).asFile
+      new ZipOutputStream(outputFile.newOutputStream()).withStream { output ->
+        eachEntry(zip) { ZipEntry entry ->
+          output.putNextEntry(new ZipEntry(entry.name))
+          if (!entry.isDirectory()) {
+            zip.getInputStream(entry).withStream { input ->
+              if (entry.name.endsWith(".class")) {
+                def bytes = transformClass(input, superClasses)
+                IOUtils.write(bytes, output)
+              } else {
+                IOUtils.copy(input, output)
+              }
+            }
+          }
+          output.closeEntry()
+        }
+      }
+    }
+  }
+
+  private byte[] transformClass(InputStream stream, Map<String, String> superClasses) {
+    def reader = new ClassReader(stream)
+    def writer = new HierarchyClassWriter(superClasses)
+    reader.accept(new UpgradingClassVisitor(writer), 0)
+    return writer.toByteArray()
+  }
+
+  private void eachEntry(ZipFile zip, Closure<?> callback) {
+    zip.entries().iterator().each { ZipEntry entry ->
+      callback(entry)
+    }
+  }
+}

buildSrc/src/main/groovy/com/intellij/rt/coverage/utils/HierarchyClassWriter.groovy

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2000-2024 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.intellij.rt.coverage.utils
+
+import groovy.transform.CompileStatic
+import org.objectweb.asm.ClassWriter
+
+@CompileStatic
+class HierarchyClassWriter extends ClassWriter {
+  private final Map<String, String> superClasses
+  private final Map<String, LinkedHashSet<String>> hierarchies = [:]
+
+  HierarchyClassWriter(Map<String, String> superClasses) {
+    super(COMPUTE_FRAMES)
+    this.superClasses = superClasses
+  }
+
+  @Override
+  protected String getCommonSuperClass(String type1, String type2) {
+    def hierarchy1 = getHierarchy(type1)
+    def hierarchy2 = getHierarchy(type2)
+    return hierarchy1.find { it in hierarchy2 }
+  }
+
+  private LinkedHashSet<String> getHierarchy(String type) {
+    LinkedHashSet<String> result = hierarchies[type]
+    if (result != null) {
+      return result
+    }
+    result = []
+    hierarchies[type] = result
+    while (type != null) {
+      result << type
+      type = getSuperClass(type)
+    }
+    result << "java/lang/Object"
+    return result
+  }
+
+  private String getSuperClass(String type) {
+    String known = superClasses[type]
+    if (known != null) {
+      return known
+    }
+    def clazz = Class.forName(type.replace('/', '.'), false, classLoader)
+    return clazz.superclass?.name?.replace('.', '/')
+  }
+}

buildSrc/src/main/groovy/com/intellij/rt/coverage/utils/UpgradingClassVisitor.groovy

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2000-2024 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.intellij.rt.coverage.utils
+
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.MethodVisitor
+import org.objectweb.asm.Opcodes
+import org.objectweb.asm.commons.JSRInlinerAdapter
+
+class UpgradingClassVisitor extends ClassVisitor {
+  private int version
+
+  protected UpgradingClassVisitor(ClassVisitor classVisitor) {
+    super(Opcodes.ASM9, classVisitor)
+  }
+
+  @Override
+  void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+    this.version = version
+    if (version < Opcodes.V11) {
+      version = Opcodes.V11
+    }
+    super.visit(version, access, name, signature, superName, interfaces)
+  }
+
+  @Override
+  MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+    def mv = super.visitMethod(access, name, descriptor, signature, exceptions)
+    if (version < Opcodes.V1_7) {
+      return new JSRInlinerAdapter(mv, access, name, descriptor, signature, exceptions)
+    }
+    return mv
+  }
+}