Merge branch 'EngineHub:version/7.3.x' into version/7.3.x

.gitignore

@@ -14,6 +14,7 @@ target
 forge-download
 out
 run
+.jqwik-database
 
 /dependency-reduced-pom.xml
 *-private.sh

build-logic/src/main/kotlin/buildlogic.common-java.gradle.kts

@@ -30,14 +30,17 @@ configure<CheckstyleExtension> {
 }
 
 tasks.withType<Test>().configureEach {
-    useJUnitPlatform()
+    useJUnitPlatform {
+        includeEngines("junit-jupiter", "jqwik")
+    }
 }
 
 dependencies {
     "compileOnly"(stringyLibs.getLibrary("jsr305"))
     "testImplementation"(platform(stringyLibs.getLibrary("junit-bom")))
     "testImplementation"(stringyLibs.getLibrary("junit-jupiter-api"))
     "testImplementation"(stringyLibs.getLibrary("junit-jupiter-params"))
+    "testImplementation"(stringyLibs.getLibrary("jqwik"))
     "testImplementation"(platform(stringyLibs.getLibrary("mockito-bom")))
     "testImplementation"(stringyLibs.getLibrary("mockito-core"))
     "testImplementation"(stringyLibs.getLibrary("mockito-junit-jupiter"))

gradle/libs.versions.toml

@@ -66,6 +66,8 @@ junit-jupiter-api.module = "org.junit.jupiter:junit-jupiter-api"
 junit-jupiter-params.module = "org.junit.jupiter:junit-jupiter-params"
 junit-jupiter-engine.module = "org.junit.jupiter:junit-jupiter-engine"
 
+jqwik = "net.jqwik:jqwik:1.9.0"
+
 mockito-bom = "org.mockito:mockito-bom:5.11.0"
 mockito-core.module = "org.mockito:mockito-core"
 mockito-junit-jupiter.module = "org.mockito:mockito-junit-jupiter"

worldedit-core/src/main/java/com/sk89q/worldedit/EditSession.java

@@ -32,6 +32,7 @@
 import com.sk89q.worldedit.extent.NullExtent;
 import com.sk89q.worldedit.extent.TracingExtent;
 import com.sk89q.worldedit.extent.buffer.ForgetfulExtentBuffer;
+import com.sk89q.worldedit.extent.buffer.internal.BatchingExtent;
 import com.sk89q.worldedit.extent.cache.LastAccessExtentCache;
 import com.sk89q.worldedit.extent.inventory.BlockBag;
 import com.sk89q.worldedit.extent.inventory.BlockBagExtent;
@@ -200,6 +201,7 @@ public String getDisplayName() {
 
     private @Nullable SideEffectExtent sideEffectExtent;
     private final SurvivalModeExtent survivalExtent;
+    private @Nullable BatchingExtent batchingExtent;
     private @Nullable ChunkBatchingExtent chunkBatchingExtent;
     private final BlockBagExtent blockBagExtent;
     @SuppressWarnings("deprecation")
@@ -269,6 +271,7 @@ public String getDisplayName() {
             this.bypassReorderHistory = traceIfNeeded(new DataValidatorExtent(extent, world));
 
             // This extent can be skipped by calling rawSetBlock()
+            extent = traceIfNeeded(batchingExtent = new BatchingExtent(extent));
             @SuppressWarnings("deprecation")
             MultiStageReorder reorder = new MultiStageReorder(extent, false);
             extent = traceIfNeeded(reorderExtent = reorder);
@@ -559,7 +562,7 @@ public void setSideEffectApplier(SideEffectSet sideEffectSet) {
      */
     @Deprecated
     public boolean hasFastMode() {
-        return sideEffectExtent != null && this.sideEffectExtent.getSideEffectSet().doesApplyAny();
+        return sideEffectExtent != null && !this.sideEffectExtent.getSideEffectSet().doesApplyAny();
     }
 
     public SideEffectSet getSideEffectApplier() {
@@ -618,10 +621,12 @@ public void setBatchingChunks(boolean batchingChunks) {
             }
             return;
         }
+        assert batchingExtent != null : "same nullness as chunkBatchingExtent";
         if (!batchingChunks && isBatchingChunks()) {
             internalFlushSession();
         }
         chunkBatchingExtent.setEnabled(batchingChunks);
+        batchingExtent.setEnabled(!batchingChunks);
     }
 
     /**
@@ -650,6 +655,8 @@ public void disableBuffering() {
         setReorderMode(ReorderMode.NONE);
         if (chunkBatchingExtent != null) {
             chunkBatchingExtent.setEnabled(false);
+            assert batchingExtent != null : "same nullness as chunkBatchingExtent";
+            batchingExtent.setEnabled(true);
         }
     }
 

worldedit-core/src/main/java/com/sk89q/worldedit/extent/buffer/internal/BatchingExtent.java

@@ -0,0 +1,111 @@
+/*
+ * WorldEdit, a Minecraft world manipulation toolkit
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) WorldEdit team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.sk89q.worldedit.extent.buffer.internal;
+
+import com.google.common.base.Throwables;
+import com.sk89q.worldedit.WorldEditException;
+import com.sk89q.worldedit.extent.AbstractBufferingExtent;
+import com.sk89q.worldedit.extent.Extent;
+import com.sk89q.worldedit.function.operation.Operation;
+import com.sk89q.worldedit.function.operation.RunContext;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.util.collection.BlockMap;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import com.sk89q.worldedit.world.block.BlockStateHolder;
+
+/**
+ * An extent that buffers all changes until completed.
+ */
+public class BatchingExtent extends AbstractBufferingExtent {
+
+    private final BlockMap<BaseBlock> blockMap = BlockMap.createForBaseBlock();
+    private boolean enabled;
+
+    public BatchingExtent(Extent extent) {
+        this(extent, true);
+    }
+
+    public BatchingExtent(Extent extent, boolean enabled) {
+        super(extent);
+        this.enabled = enabled;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    public boolean commitRequired() {
+        return enabled;
+    }
+
+    @Override
+    public <B extends BlockStateHolder<B>> boolean setBlock(BlockVector3 location, B block) throws WorldEditException {
+        if (!enabled) {
+            return setDelegateBlock(location, block);
+        }
+        blockMap.put(location, block.toBaseBlock());
+        return true;
+    }
+
+    @Override
+    protected BaseBlock getBufferedFullBlock(BlockVector3 position) {
+        if (!enabled) {
+            // Early exit if we're not enabled.
+            return null;
+        }
+        return blockMap.get(position);
+    }
+
+    @Override
+    protected Operation commitBefore() {
+        if (!commitRequired()) {
+            return null;
+        }
+        return new Operation() {
+
+            @Override
+            public Operation resume(RunContext run) throws WorldEditException {
+                try {
+                    blockMap.forEach((position, block) -> {
+                        try {
+                            getExtent().setBlock(position, block);
+                        } catch (WorldEditException e) {
+                            throw new RuntimeException(e);
+                        }
+                    });
+                } catch (RuntimeException e) {
+                    Throwables.throwIfInstanceOf(e.getCause(), WorldEditException.class);
+                    throw e;
+                }
+                blockMap.clear();
+                return null;
+            }
+
+            @Override
+            public void cancel() {
+            }
+        };
+    }
+
+}

worldedit-core/src/main/java/com/sk89q/worldedit/extent/reorder/ChunkBatchingExtent.java

@@ -31,7 +31,6 @@
 import com.sk89q.worldedit.world.block.BlockStateHolder;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 
 /**
@@ -91,18 +90,11 @@ protected Operation commitBefore() {
         }
         return new Operation() {
 
-            // we get modified between create/resume -- only create this on resume to prevent CME
-            private Iterator<BlockVector3> iterator;
-
             @Override
             public Operation resume(RunContext run) throws WorldEditException {
-                if (iterator == null) {
-                    List<BlockVector3> blockVectors = new ArrayList<>(blockMap.keySet());
-                    RegionOptimizedVectorSorter.sort(blockVectors);
-                    iterator = blockVectors.iterator();
-                }
-                while (iterator.hasNext()) {
-                    BlockVector3 position = iterator.next();
+                List<BlockVector3> blockVectors = new ArrayList<>(blockMap.keySet());
+                RegionOptimizedVectorSorter.sort(blockVectors);
+                for (BlockVector3 position : blockVectors) {
                     BaseBlock block = blockMap.get(position);
                     getExtent().setBlock(position, block);
                 }

worldedit-core/src/main/java/com/sk89q/worldedit/util/SideEffectSet.java

@@ -19,11 +19,12 @@
 
 package com.sk89q.worldedit.util;
 
+import com.google.common.base.Verify;
 import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
 
 import java.util.Arrays;
-import java.util.EnumMap;
+import java.util.EnumSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.Function;
@@ -37,33 +38,73 @@ public class SideEffectSet {
             .collect(Collectors.toMap(Function.identity(), state -> SideEffect.State.OFF))
     );
 
-    private final Map<SideEffect, SideEffect.State> sideEffects;
-    private final Set<SideEffect> appliedSideEffects;
-    private final boolean appliesAny;
+    static {
+        Verify.verify(
+            SideEffect.State.values().length == 3,
+            "Implementation requires specifically 3 values in the SideEffect.State enum"
+        );
+        int maxEffects = Integer.SIZE / 2;
+        Verify.verify(
+            SideEffect.values().length <= maxEffects,
+            "Implementation requires less than " + maxEffects + " side effects"
+        );
+        Verify.verify(
+            SideEffect.State.OFF.ordinal() == 0,
+            "Implementation requires SideEffect.State.OFF to be the first value"
+        );
+    }
+
+    private static int shift(SideEffect effect) {
+        return effect.ordinal() * 2;
+    }
+
+    private static int computeSideEffectsBitmap(Map<SideEffect, SideEffect.State> sideEffects) {
+        int sideEffectsBitmap = 0;
+        for (SideEffect effect : SideEffect.values()) {
+            SideEffect.State state = sideEffects.getOrDefault(effect, effect.getDefaultValue());
+            sideEffectsBitmap |= (state.ordinal() << shift(effect));
+        }
+        return sideEffectsBitmap;
+    }
+
+    /**
+     * Side-effects and state are encoded into this field, 2 bits per side-effect. Least-significant bit is first.
+     */
+    private final int sideEffectsBitmap;
+    private final Set<SideEffect> sideEffectsToApply;
 
     public SideEffectSet(Map<SideEffect, SideEffect.State> sideEffects) {
-        this.sideEffects = Maps.immutableEnumMap(sideEffects);
-
-        appliedSideEffects = sideEffects.entrySet()
-                .stream()
-                .filter(entry -> entry.getValue() != SideEffect.State.OFF)
-                .map(Map.Entry::getKey)
-                .collect(Collectors.toSet());
-        appliesAny = !appliedSideEffects.isEmpty();
+        this(computeSideEffectsBitmap(sideEffects));
+    }
+
+    private SideEffectSet(int sideEffectsBitmap) {
+        this.sideEffectsBitmap = sideEffectsBitmap;
+        var sideEffectsToApply = EnumSet.noneOf(SideEffect.class);
+        for (SideEffect effect : SideEffect.values()) {
+            if (shouldApply(effect)) {
+                sideEffectsToApply.add(effect);
+            }
+        }
+        this.sideEffectsToApply = Sets.immutableEnumSet(sideEffectsToApply);
     }
 
     public SideEffectSet with(SideEffect sideEffect, SideEffect.State state) {
-        Map<SideEffect, SideEffect.State> entries = this.sideEffects.isEmpty() ? Maps.newEnumMap(SideEffect.class) : new EnumMap<>(this.sideEffects);
-        entries.put(sideEffect, state);
-        return new SideEffectSet(entries);
+        int mask = 0b11 << shift(sideEffect);
+        int newState = (state.ordinal() << shift(sideEffect)) & mask;
+        int newBitmap = (sideEffectsBitmap & ~mask) | newState;
+        return new SideEffectSet(newBitmap);
     }
 
     public boolean doesApplyAny() {
-        return this.appliesAny;
+        return sideEffectsBitmap != 0;
     }
 
     public SideEffect.State getState(SideEffect effect) {
-        return sideEffects.getOrDefault(effect, effect.getDefaultValue());
+        return SideEffect.State.values()[getRawState(effect)];
+    }
+
+    private int getRawState(SideEffect effect) {
+        return (sideEffectsBitmap >> shift(effect)) & 0b11;
     }
 
     /**
@@ -77,11 +118,11 @@ public SideEffect.State getState(SideEffect effect) {
      * @return Whether it should apply
      */
     public boolean shouldApply(SideEffect effect) {
-        return getState(effect) != SideEffect.State.OFF;
+        return getRawState(effect) != 0;
     }
 
     public Set<SideEffect> getSideEffectsToApply() {
-        return this.appliedSideEffects;
+        return sideEffectsToApply;
     }
 
     public static SideEffectSet defaults() {