5.27.0 - commit.1

- Port most viable patches.

Author: coredex-source

.gitignore

@@ -182,3 +182,4 @@ Temporary Items
 # Linux trash folder which might appear on any partition or disk
 .Trash-*
 
+ModernFix-NeoForge/

gradle.properties

@@ -4,15 +4,15 @@ org.gradle.jvmargs=-Xmx2G
 
 # Mod properties
 mod_id=modernfix
-version=5.26.2-build.2
+version=5.27.0-build.1
 
 # Minecraft/Fabric
-minecraft_version=26.1-pre-1
-loader_version=0.18.4
-loom_version=1.15-SNAPSHOT
+minecraft_version=26.1.2
+loader_version=0.18.6
+loom_version=1.16-SNAPSHOT
 
 # Fabric API
-fabric_api_version=0.143.11+26.1
+fabric_api_version=0.145.4+26.1.2
 
 # Dependencies
 mixinextras_version=0.4.1

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/java/org/embeddedt/modernfix/ModernFix.java

@@ -13,6 +13,7 @@
 import org.embeddedt.modernfix.platform.ModernFixPlatformHooks;
 import org.embeddedt.modernfix.resources.ReloadExecutor;
 import org.embeddedt.modernfix.util.ClassInfoManager;
+import org.spongepowered.asm.mixin.MixinEnvironment;
 
 import java.lang.management.ManagementFactory;
 
@@ -35,7 +36,7 @@ public class ModernFix {
 
     static {
         if(ModernFixMixinPlugin.instance.isOptionEnabled("perf.dedicated_reload_executor.ReloadExecutor")) {
-            resourceReloadService = ReloadExecutor.createCustomResourceReloadExecutor();
+            resourceReloadService = new TracingExecutor(ReloadExecutor.createCustomResourceReloadExecutor());
         } else {
             resourceReloadService = Util.backgroundExecutor();
         }
@@ -45,6 +46,15 @@ public static TracingExecutor resourceReloadExecutor() {
         return resourceReloadService;
     }
 
+    public static void runAuditIfRequested() {
+        boolean auditAndExit = Boolean.getBoolean("modernfix.auditAndExit");
+        if (auditAndExit || Boolean.getBoolean("modernfix.auditMixinsAtStart")) {
+            MixinEnvironment.getCurrentEnvironment().audit();
+            if (auditAndExit) {
+                System.exit(0);
+            }
+        }
+    }
 
     public ModernFix() {
         INSTANCE = this;

src/main/java/org/embeddedt/modernfix/ModernFixClient.java

@@ -1,10 +1,8 @@
 package org.embeddedt.modernfix;
 
 import net.minecraft.client.Minecraft;
-import net.minecraft.network.syncher.EntityDataAccessor;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.MemoryReserve;
-import net.minecraft.world.entity.Entity;
 import org.embeddedt.modernfix.api.constants.IntegrationConstants;
 import org.embeddedt.modernfix.api.entrypoint.ModernFixClientIntegration;
 import org.embeddedt.modernfix.core.ModernFixMixinPlugin;
@@ -98,25 +96,6 @@ public void onRenderTickEnd() {
         }
     }
 
-    /**
-     * Check if the IDs match and remap them if not.
-     * @return true if ID remap was needed
-     */
-    private static boolean compareAndSwitchIds(Class<? extends Entity> eClass, String fieldName, EntityDataAccessor<?> accessor, int newId) {
-        if(accessor.id != newId) {
-            ModernFix.LOGGER.warn("Corrected ID mismatch on {} field {}. Client had {} but server wants {}.",
-                    eClass,
-                    fieldName,
-                    accessor.id,
-                    newId);
-            accessor.id = newId;
-            return true;
-        } else {
-            ModernFix.LOGGER.debug("{} {} ID fine: {}", eClass, fieldName, newId);
-            return false;
-        }
-    }
-
     public void onServerStarted(MinecraftServer server) {
         if(!ModernFixMixinPlugin.instance.isOptionEnabled("feature.integrated_server_watchdog.IntegratedWatchdog"))
             return;

src/main/java/org/embeddedt/modernfix/blockstate/BlockStateCacheHandler.java

@@ -6,7 +6,7 @@
 import org.embeddedt.modernfix.duck.IBlockState;
 
 public class BlockStateCacheHandler {
-    public static void rebuildParallel(boolean force) {
+    public static void invalidateCache() {
         synchronized (BlockBehaviour.BlockStateBase.class) {
             for (BlockState blockState : Block.BLOCK_STATE_REGISTRY) {
                 ((IBlockState)blockState).clearCache();

src/main/java/org/embeddedt/modernfix/command/ModernFixCommands.java

@@ -2,21 +2,17 @@
 
 import com.mojang.brigadier.CommandDispatcher;
 import net.minecraft.commands.CommandSourceStack;
-import net.minecraft.commands.Commands;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.permissions.Permissions;
 import org.embeddedt.modernfix.duck.IProfilingServerFunctionManager;
 
-
 import static net.minecraft.commands.Commands.literal;
 
 public class ModernFixCommands {
-
-
     public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
         dispatcher.register(literal("modernfix")
-                .requires(Commands.hasPermission(Commands.LEVEL_ADMINS))
-                .then(literal("mcfunctions").requires(Commands.hasPermission(Commands.LEVEL_ADMINS))
+                .then(literal("mcfunctions").requires(source -> source.permissions().hasPermission(Permissions.COMMANDS_ADMIN))
                         .executes(context -> {
                             ServerLevel level = context.getSource().getLevel();
                             if(level == null) {

src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/chunk_deadlock/ChunkMapLoadMixin.java

@@ -0,0 +1,90 @@
+package org.embeddedt.modernfix.common.mixin.bugfix.chunk_deadlock;
+
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.CrashReport;
+import net.minecraft.ReportedException;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.status.ChunkStatusTasks;
+import net.minecraft.world.level.chunk.status.WorldGenContext;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Supplier;
+
+@Mixin(ChunkStatusTasks.class)
+public abstract class ChunkMapLoadMixin {
+    @Unique
+    private static final ThreadLocal<CompletableFuture<ChunkAccess>> MFIX_SURROGATE_FUTURE = new ThreadLocal<>();
+
+    /**
+     * @author embeddedt
+     * @reason This redirect makes several changes to how full chunk promotion works. First of all, promotion runs
+     * directly in the context of the main thread executor, rather than going through the priority sorter.
+     * This change allows attempts to load other chunks from within the promotion lambda to succeed (important
+     * for bad EntityJoinLevelEvent implementations to not deadlock the game). Second, it slightly alters the
+     * semantics of protoChunkToFullChunk so that the FULL chunk future will be completed before postload
+     * callbacks finish running. This change allows attempts to load the _same_ chunk in the promotion lambda to
+     * succeed, as otherwise the future would block waiting for itself to complete.
+     *
+     * <p>This is a cleaner version of a similar trick used in ModernFix versions for 1.16, which deferred specifically
+     * entity addition to happen outside the futures.
+     */
+    @Redirect(method = "full", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;supplyAsync(Ljava/util/function/Supplier;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;", ordinal = 0))
+    private static CompletableFuture<ChunkAccess> createSurrogateFuture(Supplier<ChunkAccess> supplier, Executor executor,
+                                                                        @Local(ordinal = 0, argsOnly = true) WorldGenContext worldGenContext) {
+        var surrogate = new CompletableFuture<ChunkAccess>();
+        // Unlike vanilla, we execute the promotion lambda in mainThreadExecutor, rather than within the context
+        // of the task sorter. Doing this avoids deadlocking the sorter if a blocking chunk load is attempted
+        // during chunk promotion. We still initially compose the future through the sorter's executor to stop promotion
+        // from running earlier than it would in vanilla.
+        var mainThreadExecutor = ((ServerChunkCacheAccessor) worldGenContext.level().getChunkSource()).mfix$getMainThreadProcessor();
+        CompletableFuture.runAsync(() -> {}, executor).thenApplyAsync($ -> {
+            // running on thread that executes lambda body
+            MFIX_SURROGATE_FUTURE.set(surrogate);
+            try {
+                return supplier.get();
+            } finally {
+                MFIX_SURROGATE_FUTURE.remove();
+            }
+        }, mainThreadExecutor).whenComplete((either, throwable) -> {
+            if (throwable != null) {
+                if (!surrogate.isDone()) {
+                    surrogate.completeExceptionally(throwable);
+                } else {
+                    // The chunk has already become visible at FULL status, so we
+                    // track the exception ourselves and manually rethrow it at the right point
+                    // to trigger a server crash
+                    var exc = new ReportedException(CrashReport.forThrowable(throwable, "Exception during promotion of chunk to FULL status"));
+                    mainThreadExecutor.schedule(() -> {
+                        throw exc;
+                    });
+                }
+            } else {
+                surrogate.complete(either);
+            }
+        });
+        // Return the surrogate
+        return surrogate;
+    }
+
+    /**
+     * @author embeddedt
+     * @reason Complete the surrogate future as soon as basic promotion is done, and before we start loading entities
+     * & block entities. This allows EntityJoinLevelEvent to read the current chunk.
+     */
+    @Inject(method = "lambda$full$0", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/chunk/LevelChunk;runPostLoad()V"))
+    private static void completeSurrogateFuture(CallbackInfoReturnable<ChunkAccess> cir, @Local(ordinal = 0) LevelChunk levelChunk) {
+        var future = MFIX_SURROGATE_FUTURE.get();
+        if (future != null) {
+            future.complete(levelChunk);
+        }
+    }
+}

src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/chunk_deadlock/ServerChunkCacheAccessor.java

@@ -0,0 +1,11 @@
+package org.embeddedt.modernfix.common.mixin.bugfix.chunk_deadlock;
+
+import net.minecraft.server.level.ServerChunkCache;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(ServerChunkCache.class)
+public interface ServerChunkCacheAccessor {
+    @Accessor("mainThreadProcessor")
+    ServerChunkCache.MainThreadExecutor mfix$getMainThreadProcessor();
+}

src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/cofh_core_crash/FlagManagerMixin.java

@@ -0,0 +1,55 @@
+package org.embeddedt.modernfix.common.mixin.bugfix.cofh_core_crash;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import org.embeddedt.modernfix.annotation.RequiresMod;
+import org.spongepowered.asm.mixin.*;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Coerce;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Method;
+
+/**
+ * Fix getOrCreateFlag accessing the FLAGS map without synchronization by wrapping all calls to it
+ * in a synchronized block.
+ */
+@Pseudo
+@Mixin(targets = { "cofh/lib/util/flags/FlagManager" }, remap = false)
+@RequiresMod("cofh_core")
+public class FlagManagerMixin {
+    @Shadow @Final
+    private static Object2ObjectOpenHashMap<String, ?> FLAGS;
+
+    @Unique
+    private static final MethodHandle mfix$getOrCreateFlag;
+
+    static {
+        // use this reflection dance to avoid depending on whether it's implemented via BooleanSupplier or Supplier<Boolean>
+        try {
+            Method m = MethodHandles.lookup().lookupClass().getDeclaredMethod("getOrCreateFlag", String.class);
+            m.setAccessible(true);
+            mfix$getOrCreateFlag = MethodHandles.lookup().unreflect(m);
+        } catch(ReflectiveOperationException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    @Redirect(method = "*", at = @At(value = "INVOKE", target = "getOrCreateFlag"), require = 0)
+    @Coerce
+    private Object getFlag(@Coerce Object flagHandler, String flag) {
+        if(flagHandler != this)
+            throw new AssertionError("Redirect targeted bad getOrCreateFlag invocation");
+        synchronized (FLAGS) {
+            try {
+                return mfix$getOrCreateFlag.invoke((Object)this, flag);
+            } catch(Throwable e) {
+                if(e instanceof RuntimeException)
+                    throw (RuntimeException)e;
+                else
+                    throw new RuntimeException(e);
+            }
+        }
+    }
+}