More version hacks to make sure the new downgrade backend always runs

Even on versions it technically does not support

Author: Col-E

recaf-core/src/main/java/software/coley/recaf/util/JavaDowngraderUtil.java

@@ -3,17 +3,22 @@
 import jakarta.annotation.Nonnull;
 import jakarta.annotation.Nullable;
 import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Type;
 import org.objectweb.asm.tree.ClassNode;
 import org.slf4j.Logger;
 import software.coley.recaf.analytics.logging.Logging;
 import software.coley.recaf.services.inheritance.InheritanceGraph;
 import software.coley.recaf.util.visitors.WorkspaceClassWriter;
 import xyz.wagyourtail.jvmdg.ClassDowngrader;
 import xyz.wagyourtail.jvmdg.cli.Flags;
+import xyz.wagyourtail.jvmdg.util.Pair;
+import xyz.wagyourtail.jvmdg.version.map.MemberNameAndDesc;
 
 import java.io.IOException;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;
 
@@ -71,23 +76,24 @@ public static void downgrade(int targetJavaVersion,
 		flags.classVersion = targetClassVersion;
 
 		try (ClassDowngrader downgrader = new RecafClassDowngrader(flags, inheritanceGraph)) {
+			int maxClassFileVersion = downgrader.maxVersion();
 			classes.forEach((className, classBytes) -> {
-				// Convert class file version to Java version.
-				int classJavaVersion = classBytes[7] - JavaVersion.VERSION_OFFSET;
+				int classFileVersion = classBytes[7];
 
 				// Hack to ensure downgrader will run on bleeding edge versions of Java.
 				// This will cause brand-new features to not be properly downgraded, but
 				// not all bleeding edge classes use all the brand-new features. At least
 				// trying is better than failing outright for most use cases.
-				if (classJavaVersion > downgrader.maxVersion()) {
+				if (classFileVersion > maxClassFileVersion) {
 					classBytes = Arrays.copyOf(classBytes, classBytes.length);
-					classBytes[7] = (byte) (downgrader.maxVersion() + JavaVersion.VERSION_OFFSET);
+					classBytes[7] = (byte) (maxClassFileVersion);
 				}
 
-				// Transform if class version is greater than the target.
-				if (classJavaVersion > targetJavaVersion) {
+				// Transform if current class's version is greater than the target.
+				if (classFileVersion > targetClassVersion) {
 					try {
-						Map<String, byte[]> downgraded = downgrader.downgrade(new AtomicReference<>(className), classBytes, false, classes::get);
+						Map<String, byte[]> downgraded = downgrader.downgrade(new AtomicReference<>(className), classBytes, false,
+								key -> getBytes(maxClassFileVersion, classes, key));
 						if (downgraded != null)
 							downgraded.forEach(transformConsumer);
 					} catch (Throwable t) {
@@ -98,13 +104,53 @@ public static void downgrade(int targetJavaVersion,
 		}
 	}
 
+	@Nullable
+	private static byte[] getBytes(int maxClassFileVersion, @Nonnull Map<String, byte[]> classes, @Nonnull String key) {
+		byte[] classBytes = classes.get(key);
+		if (classBytes != null) {
+			// Same version hack as above.
+			int classFileVersion = classBytes[7];
+			if (classFileVersion > maxClassFileVersion) {
+				classBytes = Arrays.copyOf(classBytes, classBytes.length);
+				classBytes[7] = (byte) (maxClassFileVersion);
+			}
+		}
+		return classBytes;
+	}
+
 	private static class RecafClassDowngrader extends ClassDowngrader {
 		private final InheritanceGraph inheritanceGraph;
 
 		public RecafClassDowngrader(@Nonnull Flags flags, @Nullable InheritanceGraph inheritanceGraph) {
 			super(flags);
 
 			this.inheritanceGraph = inheritanceGraph;
+
+			// Compute the max-version. For the override methods below there are some cases where the base
+			// implementation does version checks on classes used only for computing basic structure data.
+			// We want these to at least have the chance to run vs failing outright, so we will cap the passed
+			// version to the max supported by this downgrader.
+			maxVersion();
+		}
+
+		@Override
+		public Set<MemberNameAndDesc> getMembers(int version, Type type, Set<String> warnings) throws IOException {
+			return super.getMembers(Math.min(maxVersion, version), type, warnings);
+		}
+
+		@Override
+		public List<Pair<Type, Boolean>> getSupertypes(int version, Type type, Set<String> warnings) throws IOException {
+			return super.getSupertypes(Math.min(maxVersion, version), type, warnings);
+		}
+
+		@Override
+		public Boolean isInterface(int version, Type type, Set<String> warnings) throws IOException {
+			return super.isInterface(Math.min(maxVersion, version), type, warnings);
+		}
+
+		@Override
+		public Type stubClass(int version, Type type, Set<String> warnings) {
+			return super.stubClass(Math.min(maxVersion, version), type, warnings);
 		}
 
 		@Override