Add support to run some Java11 code on Java8 JVMs

Author: Fox2Code

betacraft/build.gradle

@@ -5,7 +5,7 @@ dependencies {
     // compileOnly("com.github.Vatuu:discord-rpc:1.6.2")
     // compileOnly("aaaaaaaa:bbbbbbb:1.0.0") something.repo/aaaaaaaa/bbbbbbb/1.0.0/bbbbbbb-1.0.0.pom
 
-    // Let's use betacraft project fir client dev runs.
+    // Let's use betacraft project for client dev runs.
     implementation(project(":client"))
 
     //noinspection GradlePackageUpdate

common/src/main/java/com/fox2code/foxloader/launcher/FoxClassLoader.java

@@ -64,10 +64,13 @@ protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundE
             Class<?> c = findLoadedClass(name);
             if (c == null) {
                 URL resource = findResource(name.replace('.', '/') + ".class");
-                if (resource != null)
+                if (resource != null) {
                     c = findClass(name, resource);
-                else
+                } else try {
                     c = super.loadClass(name, false);
+                } catch (SecurityException securityException) {
+                    throw new ClassNotFoundException(name, securityException);
+                }
             }
             return c;
         }

common/src/main/java/com/fox2code/foxloader/loader/FoxWrappedExtensions.java

@@ -2,8 +2,11 @@
 
 import com.fox2code.foxloader.launcher.ClassTransformer;
 import com.fox2code.foxloader.launcher.FoxClassLoader;
+import com.fox2code.foxloader.launcher.utils.Platform;
 import com.fox2code.foxloader.loader.rebuild.ClassDataProvider;
+import com.fox2code.foxloader.loader.transformer.JvmCompatTransformer;
 import org.objectweb.asm.*;
+import org.objectweb.asm.commons.ClassRemapper;
 
 import java.util.logging.Logger;
 
@@ -20,7 +23,10 @@ public final class FoxWrappedExtensions extends FoxClassLoader.WrappedExtensions
     public byte[] computeFrames(byte[] classData) {
         ClassReader classReader = new ClassReader(classData);
         ClassWriter classWriter = classDataProvider.newClassWriter();
-        classReader.accept(new ClassVisitor(ClassTransformer.ASM_BUILD, classWriter) {
+        JvmCompatTransformer jvmCompatTransformer = PreLoader.getJvmCompatTransformer();
+        classReader.accept(new ClassVisitor(ClassTransformer.ASM_BUILD,
+                jvmCompatTransformer == null ? classWriter : // Fix Java11 code
+                        new ClassRemapper(classWriter, jvmCompatTransformer)) {
             @Override
             public MethodVisitor visitMethod(int access, final String name, final String descriptor, String signature, String[] exceptions) {
                 return new MethodVisitor(ClassTransformer.ASM_BUILD, super.visitMethod(access, name, descriptor, signature, exceptions)) {

common/src/main/java/com/fox2code/foxloader/loader/PreLoader.java

@@ -3,10 +3,12 @@
 import com.fox2code.foxloader.launcher.BuildConfig;
 import com.fox2code.foxloader.launcher.FoxClassLoader;
 import com.fox2code.foxloader.launcher.FoxLauncher;
+import com.fox2code.foxloader.launcher.utils.Platform;
 import com.fox2code.foxloader.loader.rebuild.ClassDataProvider;
 import com.fox2code.foxloader.loader.transformer.*;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.ClassRemapper;
 import org.objectweb.asm.tree.ClassNode;
 
 import java.io.*;
@@ -33,6 +35,7 @@ public class PreLoader {
     private static final byte[] metaInf = ("Manifest-Version: 1.0\n" +
             "FoxLoader-Transformer-Version: " + BuildConfig.FOXLOADER_TRANSFORMER_VERSION +
             "Multi-Release: true\n").getBytes(StandardCharsets.UTF_8);
+    private static JvmCompatTransformer jvmCompatTransformer = null;
 
     static {
         preLoadMetaJarHash.addString(BuildConfig.REINDEV_VERSION);
@@ -77,6 +80,9 @@ public static void patchForMixin(ClassNode classNode, String className) {
                 e.printStackTrace();
             }
         }
+        if (jvmCompatTransformer != null) {
+            jvmCompatTransformer.transform(classNode, className);
+        }
     }
 
     static void addCoreMod(File coreMod) {
@@ -100,6 +106,18 @@ static void initializePrePatch(boolean client) {
 
     static void loadPrePatches(boolean client) {
         preTransformers.clear();
+        if (FoxLauncher.getFoxClassLoader() != null) {
+            final int jvmVersion = Platform.getJvmVersion();
+            if (jvmVersion < 11) {
+                ModLoader.foxLoader.logger.info( // Tell the user we are doing that :3
+                        "Registering JvmCompatTransformer to run Java11 code on Java" + jvmVersion);
+                preTransformers.add(jvmCompatTransformer = new JvmCompatTransformer(jvmVersion));
+            } else {
+                ModLoader.foxLoader.logger.info( // Tell the user their jvm version
+                        "You are currently running on Java" + jvmVersion);
+                jvmCompatTransformer = null;
+            }
+        }
         registerPrePatch(new VarNameTransformer());
         registerPrePatch(new RegistryTransformer());
         if (client) {
@@ -263,4 +281,8 @@ public void freeze() {
             this.cache = this.makeHash();
         }
     }
+
+    static JvmCompatTransformer getJvmCompatTransformer() {
+        return jvmCompatTransformer;
+    }
 }

common/src/main/java/com/fox2code/foxloader/loader/transformer/JvmCompatTransformer.java

@@ -0,0 +1,55 @@
+package com.fox2code.foxloader.loader.transformer;
+
+import org.objectweb.asm.commons.Remapper;
+import org.objectweb.asm.tree.ClassNode;
+
+import java.util.Arrays;
+import java.util.HashSet;
+
+/**
+ * Allow to run up to Java11 code on a Java8 runtime
+ */
+public final class JvmCompatTransformer extends Remapper implements PreClassTransformer {
+    private static final HashSet<String> java9Cls = new HashSet<>(Arrays.asList(
+            "java/lang/invoke/StringConcatFactory", "java/util/concurrent/Flow"
+    ));
+    private static final int maxClassVersionSupport = V11;
+    public final int classVersionSupport;
+
+    public JvmCompatTransformer(int jvmVersion) {
+        int classVersionSupportTmp;
+        switch (jvmVersion) {
+            default:
+                throw new IllegalStateException("JvmCompatTransformer should not be used on java" + jvmVersion);
+            case 8:
+                classVersionSupportTmp = V1_8;
+                break;
+            case 9:
+                classVersionSupportTmp = V9;
+                break;
+            case 10:
+                classVersionSupportTmp = V10;
+        }
+        this.classVersionSupport = classVersionSupportTmp;
+    }
+
+    @Override
+    public void transform(ClassNode classNode, String className) {
+        if (classNode.version <= this.classVersionSupport ||
+                classNode.version > maxClassVersionSupport) {
+            return;
+        }
+        classNode.version = this.classVersionSupport;
+        if (this.classVersionSupport < V9) {
+            classNode.module = null;
+        }
+    }
+
+    @Override
+    public String map(String internalName) {
+        if (this.classVersionSupport > V9 && "notjava/util/concurrent/Flow".equals(internalName))
+            return "java/util/concurrent/Flow"; // <- Used in some java11 fallbacks
+        return (this.classVersionSupport < V9 && java9Cls.contains(internalName)) ||
+                internalName.startsWith("java/net/http/") ? "not" + internalName : internalName;
+    }
+}

common/src/main/resources/assets/foxloader/lang/ru_RU.lang

@@ -8,6 +8,16 @@ mods.updateMod=Обновить мод
 mods.updateReIndev=Обновить ReIndev
 mods.configureMod=Настроить мод
 mods.pack=Модпаки
+command.usage.id-meta=Должен использоваться только 1 аргумент, используйте либо id, либо id:meta
+command.usage.id-meta-twice=Следует использовать только 2 аргумента, для каждого из них, используйте либо id, либо id:meta
+command.error.creative-only=Вы должны быть в творческом режиме, чтобы выполнить эту команду
+command.error.no-area-selected=Перед использованием этой команды необходимо выделить область!
+command.error.invalid-block-id=Неверный id блока: %s
+command.error.invalid-meta-data=Неверные метаданные: %s
+command.error.changing-too-many-blocks=Вы собирались изменить %s блоков и это кажется слишком...
+command.error.internal-error=Во время выполнения команды произошла внутренняя ошибка.
+command.changing-blocks=Изменение %s блоков...
+command.done=Готово!
 
 
 # Installer strings (Note: Usable by mods too)

fallbacks/src/main/java/javax/xml/bind/annotation/adapters/HexBinaryAdapter.java

@@ -0,0 +1,22 @@
+package javax.xml.bind.annotation.adapters;
+
+import javax.xml.bind.DatatypeConverter;
+
+/**
+ * Partial Implementation For Java9 support if
+ * {@code javax.xml.bind.annotation.adapters.HexBinaryAdapter} is missing
+ */
+@Deprecated
+public class HexBinaryAdapter extends XmlAdapter<byte[], String> {
+    @Override
+    @Deprecated
+    public String unmarshal(byte[] v) throws Exception {
+        return DatatypeConverter.printHexBinary(v);
+    }
+
+    @Override
+    @Deprecated
+    public byte[] marshal(String v) throws Exception {
+        return DatatypeConverter.parseHexBinary(v);
+    }
+}

fallbacks/src/main/java/javax/xml/bind/annotation/adapters/XmlAdapter.java

@@ -0,0 +1,18 @@
+package javax.xml.bind.annotation.adapters;
+
+/**
+ * Partial Implementation For Java9 support if
+ * {@code javax.xml.bind.annotation.adapters.XmlAdapter} is missing
+ */
+@Deprecated
+@SuppressWarnings({"DeprecatedIsStillUsed"})
+public abstract class XmlAdapter<To,From> {
+    @Deprecated
+    protected XmlAdapter() {}
+
+    @Deprecated
+    public abstract To marshal(From v) throws Exception;
+
+    @Deprecated
+    public abstract From unmarshal(To v) throws Exception;
+}

fallbacks/src/main/java/notjava/lang/invoke/StringConcatFactory.java

@@ -0,0 +1,58 @@
+package notjava.lang.invoke;
+
+import java.lang.invoke.CallSite;
+import java.lang.invoke.ConstantCallSite;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+
+public class StringConcatFactory {
+    private static final char TAG_ARG = '\u0001';
+    private static final char TAG_CONST = '\u0002';
+
+    public static CallSite makeConcat(MethodHandles.Lookup lookup,
+                                      String name,
+                                      MethodType concatType) {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    public static CallSite makeConcatWithConstants(
+            MethodHandles.Lookup lookup, String name, MethodType concatType,
+            String recipe, Object... constants) throws NoSuchMethodException, IllegalAccessException {
+        String hardcodedMethodName;
+        switch (recipe) {
+            case "https://\u0001/":
+                hardcodedMethodName = "httpsUrlFormat";
+                break;
+            case "wss://\u0001/":
+                hardcodedMethodName = "wssUrlFormat";
+                break;
+            case "Request failed: \u0001":
+                hardcodedMethodName = "requestFailedFormat";
+                break;
+            case "Location header not returned: \u0001":
+                hardcodedMethodName = "locationHeaderNotReturnedFormat";
+                break;
+            default:
+                throw new UnsupportedOperationException("Not yet implemented");
+        }
+        return new ConstantCallSite(lookup.findStatic(HardCodedImpls.class, hardcodedMethodName, concatType));
+    }
+
+    public static class HardCodedImpls {
+        public static String httpsUrlFormat(String text) {
+            return String.format("https://%s/", text);
+        }
+
+        public static String wssUrlFormat(String text) {
+            return String.format("wss://%s/", text);
+        }
+
+        public static String requestFailedFormat(String text) {
+            return String.format("Request failed: %s", text);
+        }
+
+        public static String locationHeaderNotReturnedFormat(String text) {
+            return String.format("Location header not returned: %s", text);
+        }
+    }
+}

fallbacks/src/main/java/notjava/net/http/HttpClient.java

@@ -0,0 +1,65 @@
+package notjava.net.http;
+
+import java.io.IOException;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.net.SocketAddress;
+import java.net.URI;
+import notjava.net.http.impl.HttpClientBuilderImpl;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Partial Implementation For pre Java11 JVMs
+ */
+public abstract class HttpClient {
+    protected HttpClient() {}
+
+    public static HttpClient newHttpClient() {
+        return newBuilder().build();
+    }
+
+    public static Builder newBuilder() {
+        return new HttpClientBuilderImpl();
+    }
+
+    public interface Builder {
+        ProxySelector NO_PROXY = new ProxySelector() {
+            @Override
+            public List<Proxy> select(URI uri) {
+                return Collections.singletonList(Proxy.NO_PROXY);
+            }
+
+            @Override
+            public void connectFailed(URI uri, SocketAddress sa, IOException ioe) {
+                if (uri == null || sa == null || ioe == null) {
+                    throw new IllegalArgumentException("Arguments can't be null.");
+                }
+            }
+        };
+
+        Builder connectTimeout(Duration duration);
+
+        Builder proxy(ProxySelector proxySelector);
+
+        HttpClient build();
+    }
+
+    public abstract Optional<Duration> connectTimeout();
+
+    public abstract Optional<ProxySelector> proxy();
+
+    public abstract <T> HttpResponse<T> send(
+            HttpRequest request, HttpResponse.BodyHandler<T> responseBodyHandler)
+            throws IOException, InterruptedException;
+
+    public abstract <T> CompletableFuture<HttpResponse<T>> sendAsync(
+            HttpRequest request, HttpResponse.BodyHandler<T> responseBodyHandler);
+
+    public WebSocket.Builder newWebSocketBuilder() {
+        throw new UnsupportedOperationException();
+    }
+}