Update to Forge 47.4.12

Author: Mgazul

README.md

@@ -4,7 +4,7 @@
 ### Minecraft Forge Hybrid server implementing the Spigot/Bukkit API, formerly known as Thermos/Cauldron/MCPC+
 
 [![](https://img.shields.io/github/stars/MohistMC/Mohist.svg?label=Stars&logo=github)](https://github.com/MohistMC/Mohist/stargazers)
-[![](https://img.shields.io/badge/Forge-1.20.1--47.4.11-brightgreen.svg?colorB=26303d&logo=Conda-Forge)](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.20.1.html)
+[![](https://img.shields.io/badge/Forge-1.20.1--47.4.12-brightgreen.svg?colorB=26303d&logo=Conda-Forge)](https://files.minecraftforge.net/net/minecraftforge/forge/index_1.20.1.html)
 [![](https://img.shields.io/badge/NeoForge-1.20.1--47.1.106-brightgreen.svg?colorB=26303d)](https://neoforged.net/)
 [![](https://img.shields.io/badge/JDK-17.0.14-brightgreen.svg?colorB=469C00&logo=java)](https://www.azul.com/downloads/?version=java-17-lts#zulu)
 [![](https://img.shields.io/badge/Gradle-8.12.1-brightgreen.svg?colorB=469C00&logo=gradle)](https://docs.gradle.org/8.12.1/release-notes.html)
@@ -20,7 +20,7 @@
 Progress
 ------
 
-- [x] Rectify Forge([**1837d8c36**](https://github.com/MinecraftForge/MinecraftForge/commit/1837d8c36))
+- [x] Rectify Forge([**f20ab8e6c**](https://github.com/MinecraftForge/MinecraftForge/commit/f20ab8e6c))
 - [x] Rectify NeoForge([**e7ac32353**](https://github.com/neoforged/NeoForge/commit/e7ac32353))
 - [x] Start patch
     * [x] Bukkit([**997de31d**](https://hub.spigotmc.org/stash/projects/SPIGOT/repos/bukkit/commits/997de31d))

forge/fmlloader/src/main/java/net/minecraftforge/fml/loading/ImmediateWindowHandler.java

@@ -5,6 +5,8 @@
 
 package net.minecraftforge.fml.loading;
 
+import cpw.mods.modlauncher.Launcher;
+import cpw.mods.modlauncher.api.IModuleLayerManager;
 import net.minecraftforge.fml.loading.progress.ProgressMeter;
 import net.minecraftforge.fml.loading.progress.StartupNotificationManager;
 import org.apache.logging.log4j.LogManager;
@@ -23,28 +25,44 @@ public class ImmediateWindowHandler {
 
     private static ProgressMeter earlyProgress;
     public static void load(final String launchTarget, final String[] arguments) {
+        final var serviceLayer = Launcher.INSTANCE.findLayerManager()
+                .flatMap(manager -> manager.getLayer(IModuleLayerManager.Layer.SERVICE))
+                .orElse(null);
+        final var providerName = FMLConfig.getConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_PROVIDER);
+
         if (!List.of("forgeclient", "forgeclientuserdev", "forgeclientdev").contains(launchTarget)) {
-            provider = new DummyProvider();
             LOGGER.info("ImmediateWindowProvider not loading because launch target is {}", launchTarget);
         } else if (!FMLConfig.getBoolConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_CONTROL)) {
-            provider = new DummyProvider();
             LOGGER.info("ImmediateWindowProvider not loading because splash screen is disabled");
+        } else if (providerName == null) {
+            LOGGER.info("ImmediateWindowProvider not loading because splash screen provider is null");
+        } else if (serviceLayer == null) {
+            LOGGER.error("Failed to find service layer for ImmediateWindowProvider");
         } else {
-            final var providername = FMLConfig.getConfigValue(FMLConfig.ConfigValue.EARLY_WINDOW_PROVIDER);
-            LOGGER.info("Loading ImmediateWindowProvider {}", providername);
-            final var maybeProvider = ServiceLoader.load(ImmediateWindowProvider.class)
-                    .stream()
-                    .map(ServiceLoader.Provider::get)
-                    .filter(p -> Objects.equals(p.name(), providername))
-                    .findFirst();
-            provider = maybeProvider.or(() -> {
-                LOGGER.info("Failed to find ImmediateWindowProvider {}, disabling", providername);
-                return Optional.of(new DummyProvider());
-            }).orElseThrow();
+            LOGGER.info("Loading ImmediateWindowProvider {}", providerName);
+
+            for (var itr = ServiceLoader.load(serviceLayer, ImmediateWindowProvider.class).iterator(); itr.hasNext(); ) {
+                try {
+                    var srvc = itr.next();
+                    if (providerName.equals(srvc.name())) {
+                        provider = new Wrapper(srvc);
+                        break;
+                    }
+                } catch (ServiceConfigurationError e) {
+                    LOGGER.error("Failed to initalize ImmediateWindowProvider Service", e);
+                }
+            }
+
+            if (provider == null)
+                LOGGER.info("Failed to find ImmediateWindowProvider {}, disabling", providerName);
         }
+
         // Only update config if the provider isn't the dummy provider
-        if (!Objects.equals(provider.name(), "dummyprovider"))
+        if (provider != null)
             FMLConfig.updateConfig(FMLConfig.ConfigValue.EARLY_WINDOW_PROVIDER, provider.name());
+        else
+            provider = new DummyProvider();
+
         FMLLoader.progressWindowTick = provider.initialize(arguments);
         earlyProgress = StartupNotificationManager.addProgressBar("EARLY", 0);
         earlyProgress.label("Bootstrapping Minecraft");
@@ -78,6 +96,7 @@ public static void renderTick() {
     public static String getGLVersion() {
         return provider.getGLVersion();
     }
+
     public static void updateProgress(final String message) {
         earlyProgress.label(message);
     }
@@ -156,4 +175,94 @@ public void periodicTick() {
             // NOOP
         }
     }
+
+    // We create a wrapper because we want to log errors to the log files, which not all paths of ModLauncher do. Little dirty, but works for now.
+    private static class Wrapper implements ImmediateWindowProvider {
+        private final ImmediateWindowProvider delegate;
+
+        private Wrapper(ImmediateWindowProvider delegate) {
+            this.delegate = delegate;
+        }
+
+        public String name() {
+            try {
+                return delegate.name();
+            } catch (Throwable t) {
+                LOGGER.error("Failed to call provider.name", t);
+                throw t;
+            }
+        }
+
+        public Runnable initialize(String[] arguments) {
+            try {
+                return delegate.initialize(arguments);
+            } catch (Throwable t) {
+                LOGGER.error("Failed to call provider.initialize", t);
+                throw t;
+            }
+        }
+
+        public void updateFramebufferSize(IntConsumer width, IntConsumer height) {
+            try {
+                delegate.updateFramebufferSize(width, height);
+            } catch (Throwable t) {
+                LOGGER.error("Failed to call provider.updateFramebufferSize", t);
+                throw t;
+            }
+        }
+
+        public long setupMinecraftWindow(IntSupplier width, IntSupplier height, Supplier<String> title, LongSupplier monitor) {
+            try {
+                return delegate.setupMinecraftWindow(width, height, title, monitor);
+            } catch (Throwable t) {
+                LOGGER.error("Failed to call provider.setupMinecraftWindow", t);
+                throw t;
+            }
+        }
+
+        public boolean positionWindow(Optional<Object> monitor, IntConsumer widthSetter, IntConsumer heightSetter, IntConsumer xSetter, IntConsumer ySetter) {
+            try {
+                return delegate.positionWindow(monitor, widthSetter, heightSetter, xSetter, ySetter);
+            } catch (Throwable t) {
+                LOGGER.error("Failed to call provider.positionWindow", t);
+                throw t;
+            }
+        }
+
+        public <T> Supplier<T> loadingOverlay(Supplier<?> mc, Supplier<?> ri, Consumer<Optional<Throwable>> ex, boolean fade) {
+            try {
+                return delegate.loadingOverlay(mc, ri, ex, fade);
+            } catch (Throwable t) {
+                LOGGER.error("Failed to call provider.loadingOverlay", t);
+                throw t;
+            }
+        }
+
+        public void updateModuleReads(ModuleLayer layer) {
+            try {
+                delegate.updateModuleReads(layer);
+            } catch (Throwable t) {
+                LOGGER.error("Failed to call provider.updateModuleReads", t);
+                throw t;
+            }
+        }
+
+        public void periodicTick() {
+            try {
+                delegate.periodicTick();
+            } catch (Throwable t) {
+                LOGGER.error("Failed to call provider.periodicTick", t);
+                throw t;
+            }
+        }
+
+        public String getGLVersion() {
+            try {
+                return delegate.getGLVersion();
+            } catch (Throwable t) {
+                LOGGER.error("Failed to call provider.getGLVersion", t);
+                throw t;
+            }
+        }
+    }
 }

gradle.properties

@@ -7,7 +7,7 @@ org.gradle.daemon=false
 bukkit_version=997de31d
 craftbukkit_version=ddc9a2dad
 spigot_version=d2eba2c8
-forge_version=47.4.11
+forge_version=47.4.12
 neoforge_version=47.1.106
 mohist_group_id=com.mohistmc
 

src/main/java/net/minecraftforge/common/util/ConcatenatedListView.java

@@ -7,79 +7,68 @@
 
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.ListIterator;
-import java.util.Spliterator;
-import java.util.function.Supplier;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.*;
+import java.util.function.Supplier;
+
 /**
  * A list that concatenates multiple other lists for efficient iteration.<p/>
  * You may use this in place of creating a new list and calling {@link List#addAll(Collection)}
  * for each of your collections.<p/>
  * This list does not support modification operations, but the underlying lists may be mutated safely externally.
  */
-public class ConcatenatedListView<T> implements List<T>
-{
+public class ConcatenatedListView<T> implements List<T> {
     @SafeVarargs
-    public static <T> ConcatenatedListView<T> of(List<T>... lists)
-    {
+    public static <T> ConcatenatedListView<T> of(List<T>... lists) {
         return new ConcatenatedListView<>(List.of(lists));
     }
 
-    public static <T> List<T> of(List<? extends List<? extends T>> members)
-    {
-        return switch (members.size()) {
-            case 0 -> List.of();
-            case 1 -> Collections.unmodifiableList(members.get(0));
-            default -> new ConcatenatedListView<>(members);
-        };
+    public static <T> List<T> of(List<? extends List<? extends T>> members) {
+        if (members.isEmpty())
+            return List.of();
+        if (members.size() == 1)
+            return (Collections.unmodifiableList(members.get(0)));
+        @SuppressWarnings("unchecked")
+        var typed = (List<List<T>>)members;
+        return new ConcatenatedListView<>(typed);
     }
 
-    private final List<? extends List<? extends T>> lists;
+    private final List<List<T>> lists;
 
-    private ConcatenatedListView(List<? extends List<? extends T>> lists)
-    {
+    private ConcatenatedListView(List<List<T>> lists) {
         this.lists = lists;
     }
 
     @Override
-    public int size()
-    {
+    public int size() {
         int size = 0;
         for (var list : lists)
             size += list.size();
         return size;
     }
 
     @Override
-    public boolean isEmpty()
-    {
-        for (List<? extends T> list : lists)
+    public boolean isEmpty() {
+        for (List<? extends T> list : lists) {
             if (!list.isEmpty())
                 return false;
+        }
         return true;
     }
 
     @Override
-    public boolean contains(Object o)
-    {
-        for (var list : lists)
+    public boolean contains(Object o) {
+        for (var list : lists) {
             if (list.contains(o))
                 return true;
+        }
         return false;
     }
 
     @Override
-    public T get(int index)
-    {
-        for (var list : lists)
-        {
+    public T get(int index) {
+        for (var list : lists) {
             int size = list.size();
             if (index < size)
                 return list.get(index);
@@ -89,11 +78,9 @@ public T get(int index)
     }
 
     @Override
-    public int indexOf(Object o)
-    {
+    public int indexOf(Object o) {
         int offset = 0;
-        for (var list : lists)
-        {
+        for (var list : lists) {
             int foundIndex = list.indexOf(o);
             if (foundIndex >= 0)
                 return offset + foundIndex;
@@ -103,11 +90,9 @@ public int indexOf(Object o)
     }
 
     @Override
-    public int lastIndexOf(Object o)
-    {
+    public int lastIndexOf(Object o) {
         int offset = 0;
-        for (var list : Lists.reverse(lists))
-        {
+        for (var list : Lists.reverse(lists)) {
             int foundIndex = list.lastIndexOf(o);
             if (foundIndex >= 0)
                 return offset + foundIndex;
@@ -118,20 +103,17 @@ public int lastIndexOf(Object o)
 
     @NotNull
     @Override
-    public Iterator<T> iterator()
-    {
+    public Iterator<T> iterator() {
         return Iterables.unmodifiableIterable(Iterables.concat(lists)).iterator();
     }
 
     @Override
-    public Spliterator<T> spliterator()
-    {
+    public Spliterator<T> spliterator() {
         return Iterables.unmodifiableIterable(Iterables.concat(lists)).spliterator();
     }
 
     // Delegate to a concatenated collection
-    private <C extends Collection<T>> C concatenate(Supplier<C> collectionFactory)
-    {
+    private <C extends Collection<T>> C concatenate(Supplier<C> collectionFactory) {
         var concat = collectionFactory.get();
         for (var list : lists)
             concat.addAll(list);