Add FeatureFlag API (#8952)

* Add FeatureFlag API

* switch to index & move method

* fix test

patches/api/0270-Add-basic-Datapack-API.patch

@@ -70,7 +70,7 @@ index 0000000000000000000000000000000000000000..58f78d5e91beacaf710f62461cf869f7
 +
 +}
 diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
-index b558fa73dbcf3747690933e6aadf7061a0de2630..8a22c242a93b0e16e0bca583d0918bab695248b1 100644
+index b558fa73dbcf3747690933e6aadf7061a0de2630..be68351555bde59a4e55bf1bad261e9f6bc9f704 100644
 --- a/src/main/java/org/bukkit/Bukkit.java
 +++ b/src/main/java/org/bukkit/Bukkit.java
 @@ -328,9 +328,11 @@ public final class Bukkit {
@@ -81,7 +81,7 @@ index b558fa73dbcf3747690933e6aadf7061a0de2630..8a22c242a93b0e16e0bca583d0918bab
       * @return the manager
       */
      @NotNull
-+    @Deprecated(forRemoval = true)
++    @Deprecated(forRemoval = true, since = "1.20")
      public static DataPackManager getDataPackManager() {
          return server.getDataPackManager();
      }
@@ -100,8 +100,20 @@ index b558fa73dbcf3747690933e6aadf7061a0de2630..8a22c242a93b0e16e0bca583d0918bab
      // Paper end
  
      @NotNull
+diff --git a/src/main/java/org/bukkit/Material.java b/src/main/java/org/bukkit/Material.java
+index cc25734f3dcf6075eb44e39da01ed2f1b59b618e..2721ad40d6ba025caad16455f74f2350dcb7a4ff 100644
+--- a/src/main/java/org/bukkit/Material.java
++++ b/src/main/java/org/bukkit/Material.java
+@@ -5497,6 +5497,7 @@ public enum Material implements Keyed, Translatable, net.kyori.adventure.transla
+      * @param world the world to check
+      * @return true if this material can be used in this World.
+      */
++    @Deprecated(forRemoval = true, since = "1.20") // Paper
+     public boolean isEnabledByFeature(@NotNull World world) {
+         if (isItem()) {
+             return Bukkit.getDataPackManager().isEnabledByFeature(asItemType(), world);
 diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
-index 42930006b6425b5d82233e4ffe7025ce5397b277..67b5cb7635c4251c259b1fb1ef50f99a0b2647e5 100644
+index 42930006b6425b5d82233e4ffe7025ce5397b277..45693e6c02eac37eb609cd3c59253a949a6ca4c0 100644
 --- a/src/main/java/org/bukkit/Server.java
 +++ b/src/main/java/org/bukkit/Server.java
 @@ -267,9 +267,11 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
@@ -112,7 +124,7 @@ index 42930006b6425b5d82233e4ffe7025ce5397b277..67b5cb7635c4251c259b1fb1ef50f99a
       * @return the manager
       */
      @NotNull
-+    @Deprecated(forRemoval = true) // Paper
++    @Deprecated(forRemoval = true, since = "1.20") // Paper
      public DataPackManager getDataPackManager();
  
      /**
@@ -128,8 +140,20 @@ index 42930006b6425b5d82233e4ffe7025ce5397b277..67b5cb7635c4251c259b1fb1ef50f99a
 +    io.papermc.paper.datapack.DatapackManager getDatapackManager();
      // Paper end
  }
+diff --git a/src/main/java/org/bukkit/entity/EntityType.java b/src/main/java/org/bukkit/entity/EntityType.java
+index 976f701ed9b9873945a5628173c580e2e6873864..eea0351559a2835280713f5d5d1d430c7cf857a0 100644
+--- a/src/main/java/org/bukkit/entity/EntityType.java
++++ b/src/main/java/org/bukkit/entity/EntityType.java
+@@ -449,6 +449,7 @@ public enum EntityType implements Keyed, Translatable, net.kyori.adventure.trans
+      * @param world the world to check
+      * @return true if this EntityType can be used to spawn an Entity for this World.
+      */
++    @Deprecated(forRemoval = true, since = "1.20") // Paper
+     public boolean isEnabledByFeature(@NotNull World world) {
+         return Bukkit.getDataPackManager().isEnabledByFeature(this, world);
+     }
 diff --git a/src/main/java/org/bukkit/packs/DataPack.java b/src/main/java/org/bukkit/packs/DataPack.java
-index ea03c51d51e015e69d3aaa795547033ceabff9e0..419f6bdbec5dc1c731fb0f93816a90f58a329021 100644
+index ea03c51d51e015e69d3aaa795547033ceabff9e0..f51d59e6369c76e333fd9e58e711c2b6f245882d 100644
 --- a/src/main/java/org/bukkit/packs/DataPack.java
 +++ b/src/main/java/org/bukkit/packs/DataPack.java
 @@ -9,7 +9,9 @@ import org.jetbrains.annotations.NotNull;
@@ -138,12 +162,12 @@ index ea03c51d51e015e69d3aaa795547033ceabff9e0..419f6bdbec5dc1c731fb0f93816a90f5
   * @see <a href="https://minecraft.wiki/w/Data_pack">Minecraft wiki</a>
 + * @deprecated use {@link io.papermc.paper.datapack.Datapack}
   */
-+@Deprecated(forRemoval = true) // Paper
++@Deprecated(forRemoval = true, since = "1.20") // Paper
  public interface DataPack extends Keyed {
  
      /**
 diff --git a/src/main/java/org/bukkit/packs/DataPackManager.java b/src/main/java/org/bukkit/packs/DataPackManager.java
-index aee6e828c6fac9b010356af1239a58b4579c1773..7d3694efc21c7bc3784207735bdd9fb27e69988a 100644
+index aee6e828c6fac9b010356af1239a58b4579c1773..1b850e76a885f0da653d4b48db72e5f85ae72805 100644
 --- a/src/main/java/org/bukkit/packs/DataPackManager.java
 +++ b/src/main/java/org/bukkit/packs/DataPackManager.java
 @@ -13,7 +13,9 @@ import org.jetbrains.annotations.Nullable;
@@ -152,7 +176,7 @@ index aee6e828c6fac9b010356af1239a58b4579c1773..7d3694efc21c7bc3784207735bdd9fb2
   * Manager of data packs.
 + * @deprecated use {@link io.papermc.paper.datapack.DatapackManager}
   */
-+@Deprecated(forRemoval = true) // Paper
++@Deprecated(forRemoval = true, since = "1.20") // Paper
  public interface DataPackManager {
  
      /**

patches/api/0488-Add-FeatureFlag-API.patch

@@ -0,0 +1,333 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 9 Mar 2023 11:24:43 -0800
+Subject: [PATCH] Add FeatureFlag API
+
+
+diff --git a/src/main/java/io/papermc/paper/world/flag/FeatureDependant.java b/src/main/java/io/papermc/paper/world/flag/FeatureDependant.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..914dc0b655630dd835bb115a144206d7e3a02337
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/world/flag/FeatureDependant.java
+@@ -0,0 +1,26 @@
++package io.papermc.paper.world.flag;
++
++import java.util.Set;
++import org.bukkit.FeatureFlag;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Unmodifiable;
++
++/**
++ * Implemented by types in built-in registries that are controlled by {@link FeatureFlag FeatureFlags}.
++ * Types in data-driven registries that are controlled by feature flags just will not exist in that registry.
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface FeatureDependant {
++
++    /**
++     * Gets the set of required feature flags for this
++     * to be enabled.
++     *
++     * @return the immutable set of feature flags
++     */
++    default @Unmodifiable @NonNull Set<FeatureFlag> requiredFeatures() {
++        return FeatureFlagProvider.provider().requiredFeatures(this);
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/world/flag/FeatureFlagProvider.java b/src/main/java/io/papermc/paper/world/flag/FeatureFlagProvider.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..f64cbee35fd3c6fe7b5f7391f6d118166d26dc18
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/world/flag/FeatureFlagProvider.java
+@@ -0,0 +1,19 @@
++package io.papermc.paper.world.flag;
++
++import java.util.Optional;
++import java.util.ServiceLoader;
++import java.util.Set;
++import org.bukkit.FeatureFlag;
++import org.jetbrains.annotations.ApiStatus;
++
++@ApiStatus.Internal
++interface FeatureFlagProvider {
++
++    Optional<FeatureFlagProvider> PROVIDER = ServiceLoader.load(FeatureFlagProvider.class).findFirst();
++
++    static FeatureFlagProvider provider() {
++        return PROVIDER.orElseThrow();
++    }
++
++    Set<FeatureFlag> requiredFeatures(FeatureDependant dependant);
++}
+diff --git a/src/main/java/io/papermc/paper/world/flag/FeatureFlagSetHolder.java b/src/main/java/io/papermc/paper/world/flag/FeatureFlagSetHolder.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2d7bbc9b157ccbb02731ecf3ec6680681c9c0da8
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/world/flag/FeatureFlagSetHolder.java
+@@ -0,0 +1,32 @@
++package io.papermc.paper.world.flag;
++
++import java.util.Set;
++import org.bukkit.FeatureFlag;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Unmodifiable;
++
++/**
++ * Implemented by types that hold {@link FeatureFlag FeatureFlags} like
++ * {@link org.bukkit.generator.WorldInfo} and {@link org.bukkit.RegionAccessor}.
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface FeatureFlagSetHolder {
++
++    /**
++     * Checks if this is enabled based on the loaded feature flags.
++     *
++     * @return true if enabled
++     */
++    default boolean isEnabled(final @NonNull FeatureDependant featureDependant) {
++        return this.getFeatureFlags().containsAll(featureDependant.requiredFeatures());
++    }
++
++    /**
++     * Get all {@link FeatureFlag FeatureFlags} enabled in this world.
++     *
++     * @return all enabled {@link FeatureFlag FeatureFlags}
++     */
++    @Unmodifiable @NonNull Set<FeatureFlag> getFeatureFlags();
++}
+diff --git a/src/main/java/org/bukkit/FeatureFlag.java b/src/main/java/org/bukkit/FeatureFlag.java
+index 026b1832bcd163ab89668c991bf002e608e36aef..d690ecf6eac753fab9d09514cfadae4c6a73e146 100644
+--- a/src/main/java/org/bukkit/FeatureFlag.java
++++ b/src/main/java/org/bukkit/FeatureFlag.java
+@@ -1,37 +1,57 @@
+ package org.bukkit;
+ 
++// Paper start - overhaul FeatureFlag API
++import com.google.common.base.Preconditions;
++import java.util.List;
++import net.kyori.adventure.key.Key;
++import net.kyori.adventure.util.Index;
++import org.intellij.lang.annotations.Subst;
++// Paper end - overhaul FeatureFlag API
+ import org.jetbrains.annotations.ApiStatus;
+ 
+ /**
+  * This represents a Feature Flag for a World.
+- * <br>
+- * Flags which are unavailable in the current version will be null and/or
+- * removed.
+  */
+ @ApiStatus.Experimental
+ public interface FeatureFlag extends Keyed {
+ 
+-    public static final FeatureFlag VANILLA = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("vanilla"));
++    // Paper start - overhaul FeatureFlag API
++    /**
++     * The {@code vanilla} feature flag.
++     */
++    FeatureFlag VANILLA = create("vanilla");
+ 
++    /**
++     * The {@code bundle} feature flag.
++     */
+     @ApiStatus.Experimental // Paper - add missing annotation
+-    public static final FeatureFlag BUNDLE = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("bundle"));
++    FeatureFlag BUNDLE = create("bundle");
+ 
+     /**
+-     * <strong>AVAILABLE BETWEEN VERSIONS:</strong> 1.19 - 1.19.4
+-     *
+-     * @deprecated not available since 1.20
++     * The {@code trade_rebalance} feature flag.
+      */
+-    @Deprecated
+-    public static final FeatureFlag UPDATE_1_20 = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("update_1_20"));
+-
+     @ApiStatus.Experimental // Paper - add missing annotation
+-    public static final FeatureFlag TRADE_REBALANCE = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("trade_rebalance"));
++    FeatureFlag TRADE_REBALANCE = create("trade_rebalance");
++
++    @Deprecated(since = "1.20")
++    FeatureFlag UPDATE_1_20 = deprecated("update_1_20");
++
++    @Deprecated(since = "1.21")
++    FeatureFlag UPDATE_121 = deprecated("update_1_21");
+ 
+     /**
+-     * <strong>AVAILABLE BETWEEN VERSIONS:</strong> 1.20.5 - 1.20.6
+-     *
+-     * @deprecated not available since 1.21
++     * An index of all feature flags.
+      */
+-    @Deprecated
+-    public static final FeatureFlag UPDATE_121 = Bukkit.getUnsafe().getFeatureFlag(NamespacedKey.minecraft("update_1_21"));
++    Index<Key, FeatureFlag> ALL_FLAGS = Index.create(FeatureFlag::key, List.copyOf(FeatureFlagImpl.ALL_FLAGS));
++
++    private static FeatureFlag create(@Subst("vanilla") final String name) {
++        final FeatureFlag flag = new FeatureFlagImpl(NamespacedKey.minecraft(name));
++        Preconditions.checkState(FeatureFlagImpl.ALL_FLAGS.add(flag), "Tried to add duplicate feature flag: " + name);
++        return flag;
++    }
++
++    private static FeatureFlag deprecated(@Subst("vanilla") final String name) {
++        return new FeatureFlagImpl.Deprecated(NamespacedKey.minecraft(name));
++    }
++    // Paper end - overhaul FeatureFlag API
+ }
+diff --git a/src/main/java/org/bukkit/FeatureFlagImpl.java b/src/main/java/org/bukkit/FeatureFlagImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a33517dbd69021fde8246836720b6247800ee43c
+--- /dev/null
++++ b/src/main/java/org/bukkit/FeatureFlagImpl.java
+@@ -0,0 +1,29 @@
++package org.bukkit;
++
++import java.util.HashSet;
++import java.util.Set;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.framework.qual.DefaultQualifier;
++import org.jetbrains.annotations.ApiStatus;
++
++@ApiStatus.Internal
++@DefaultQualifier(NonNull.class)
++record FeatureFlagImpl(NamespacedKey key) implements FeatureFlag {
++
++    static final Set<FeatureFlag> ALL_FLAGS = new HashSet<>();
++
++    @Override
++    public NamespacedKey getKey() {
++        return this.key;
++    }
++
++    @ApiStatus.Internal
++    @DefaultQualifier(NonNull.class)
++    record Deprecated(NamespacedKey key) implements FeatureFlag {
++
++        @Override
++        public NamespacedKey getKey() {
++            return this.key;
++        }
++    }
++}
+diff --git a/src/main/java/org/bukkit/RegionAccessor.java b/src/main/java/org/bukkit/RegionAccessor.java
+index eb33e8e671972aa308ad75a7ce9aa9ac526f470f..05ecf3cb38ff42c8b52405d900197e6bf47dd1e6 100644
+--- a/src/main/java/org/bukkit/RegionAccessor.java
++++ b/src/main/java/org/bukkit/RegionAccessor.java
+@@ -18,7 +18,7 @@ import org.jetbrains.annotations.Nullable;
+  * A RegionAccessor gives access to getting, modifying and spawning {@link Biome}, {@link BlockState} and {@link Entity},
+  * as well as generating some basic structures.
+  */
+-public interface RegionAccessor extends Keyed { // Paper
++public interface RegionAccessor extends Keyed, io.papermc.paper.world.flag.FeatureFlagSetHolder { // Paper - feature flag API
+ 
+     /**
+      * Gets the {@link Biome} at the given {@link Location}.
+diff --git a/src/main/java/org/bukkit/UnsafeValues.java b/src/main/java/org/bukkit/UnsafeValues.java
+index 330e3013eda204aa9b33d5e1c3104e0b595abdbc..c80e0ef587a001ee6de3f5c182cc9696d58bafeb 100644
+--- a/src/main/java/org/bukkit/UnsafeValues.java
++++ b/src/main/java/org/bukkit/UnsafeValues.java
+@@ -114,8 +114,7 @@ public interface UnsafeValues {
+ 
+     String getTranslationKey(Attribute attribute);
+ 
+-    @Nullable
+-    FeatureFlag getFeatureFlag(@NotNull NamespacedKey key);
++    // Paper - replace with better system
+ 
+     /**
+      * Do not use, method will get removed, and the plugin won't run
+diff --git a/src/main/java/org/bukkit/block/BlockType.java b/src/main/java/org/bukkit/block/BlockType.java
+index 8f430a4067fc722ebfbca846cccded4fb0a3a4e5..4aa79016eb5f7edf930c82d30ff25078fdb88436 100644
+--- a/src/main/java/org/bukkit/block/BlockType.java
++++ b/src/main/java/org/bukkit/block/BlockType.java
+@@ -123,7 +123,7 @@ import org.jetbrains.annotations.Nullable;
+  * changes may occur. Do not use this API in plugins.
+  */
+ @ApiStatus.Internal
+-public interface BlockType extends Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - add translatable
++public interface BlockType extends Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - add translatable & feature flag API
+ 
+     /**
+      * Typed represents a subtype of {@link BlockType}s that have a known block
+diff --git a/src/main/java/org/bukkit/enchantments/Enchantment.java b/src/main/java/org/bukkit/enchantments/Enchantment.java
+index f38321c437b19125d57d25419e3cb564e3928d89..daf4eeed2881858f734c19471ad5dbc4e1f42def 100644
+--- a/src/main/java/org/bukkit/enchantments/Enchantment.java
++++ b/src/main/java/org/bukkit/enchantments/Enchantment.java
+@@ -15,7 +15,7 @@ import org.jetbrains.annotations.Nullable;
+ /**
+  * The various type of enchantments that may be added to armour or weapons
+  */
+-public abstract class Enchantment implements Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - Adventure translations
++public abstract class Enchantment implements Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - Adventure translations & feature flag API
+     /**
+      * Provides protection against environmental damage
+      */
+diff --git a/src/main/java/org/bukkit/entity/EntityType.java b/src/main/java/org/bukkit/entity/EntityType.java
+index ba605ad75d4ed920c0dc4527529998041a58676b..a78e1c431a6ea46ba7c44880e25a871f473bef41 100644
+--- a/src/main/java/org/bukkit/entity/EntityType.java
++++ b/src/main/java/org/bukkit/entity/EntityType.java
+@@ -23,7 +23,7 @@ import org.jetbrains.annotations.Contract;
+ import org.jetbrains.annotations.NotNull;
+ import org.jetbrains.annotations.Nullable;
+ 
+-public enum EntityType implements Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - translatable
++public enum EntityType implements Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - translatable
+ 
+     // These strings MUST match the strings in nms.EntityTypes and are case sensitive.
+     /**
+diff --git a/src/main/java/org/bukkit/generator/WorldInfo.java b/src/main/java/org/bukkit/generator/WorldInfo.java
+index 5067f1371433cccd3287af7f03e152f2c3c1ece3..e0cb282541548ac3bd24cce86b3413f5748ea8bc 100644
+--- a/src/main/java/org/bukkit/generator/WorldInfo.java
++++ b/src/main/java/org/bukkit/generator/WorldInfo.java
+@@ -7,7 +7,7 @@ import org.jetbrains.annotations.NotNull;
+ /**
+  * Holds various information of a World
+  */
+-public interface WorldInfo {
++public interface WorldInfo extends io.papermc.paper.world.flag.FeatureFlagSetHolder { // Paper - feature flag API
+ 
+     /**
+      * Gets the unique name of this world
+diff --git a/src/main/java/org/bukkit/inventory/ItemType.java b/src/main/java/org/bukkit/inventory/ItemType.java
+index 0168f0a14a3e899e84c5e36963ff79950ab580fb..86887e8b20288b8204adcc64993b39f94269a0eb 100644
+--- a/src/main/java/org/bukkit/inventory/ItemType.java
++++ b/src/main/java/org/bukkit/inventory/ItemType.java
+@@ -48,7 +48,7 @@ import org.jetbrains.annotations.Nullable;
+  * changes may occur. Do not use this API in plugins.
+  */
+ @ApiStatus.Experimental // Paper - already required for registry builders
+-public interface ItemType extends Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - add Translatable
++public interface ItemType extends Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - add Translatable & feature flag API
+ 
+     /**
+      * Typed represents a subtype of {@link ItemType}s that have a known item meta type
+diff --git a/src/main/java/org/bukkit/potion/PotionEffectType.java b/src/main/java/org/bukkit/potion/PotionEffectType.java
+index 10fa51d116b40450b51af9110d5637f3505ebf65..647452f16e4bf7e5a61520123e62d9408ec9adfb 100644
+--- a/src/main/java/org/bukkit/potion/PotionEffectType.java
++++ b/src/main/java/org/bukkit/potion/PotionEffectType.java
+@@ -17,7 +17,7 @@ import org.jetbrains.annotations.Nullable;
+ /**
+  * Represents a type of potion and its effect on an entity.
+  */
+-public abstract class PotionEffectType implements Keyed, Translatable, net.kyori.adventure.translation.Translatable { // Paper - implement Translatable
++public abstract class PotionEffectType implements Keyed, Translatable, net.kyori.adventure.translation.Translatable, io.papermc.paper.world.flag.FeatureDependant { // Paper - implement Translatable & feature flag API
+     private static final BiMap<Integer, PotionEffectType> ID_MAP = HashBiMap.create();
+ 
+     /**
+diff --git a/src/main/java/org/bukkit/potion/PotionType.java b/src/main/java/org/bukkit/potion/PotionType.java
+index 453c626092caa734a0af5800699f299fc6fd0e43..c82cc9d9db5cb0e0e3c02f6a9564fc935ee594aa 100644
+--- a/src/main/java/org/bukkit/potion/PotionType.java
++++ b/src/main/java/org/bukkit/potion/PotionType.java
+@@ -14,7 +14,7 @@ import org.jetbrains.annotations.Nullable;
+  * This enum reflects and matches each potion state that can be obtained from
+  * the Creative mode inventory
+  */
+-public enum PotionType implements Keyed {
++public enum PotionType implements Keyed, io.papermc.paper.world.flag.FeatureDependant { // Paper - feature flag API
+     WATER("water"),
+     MUNDANE("mundane"),
+     THICK("thick"),

patches/server/0648-Expose-vanilla-BiomeProvider-from-WorldInfo.patch

@@ -88,7 +88,7 @@ index 0c2734c1d06b6c5dff383f9c6139c0389f220a76..110a5d92d6154bc39c1916006a5cb747
  
      private static final Random rand = new Random();
 diff --git a/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java b/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java
-index 5d655d6cd3e23e0287069f8bdf77601487e862fd..cf57c6e9ce63f7b1d95d91ead2453409a31a5c52 100644
+index 5d655d6cd3e23e0287069f8bdf77601487e862fd..c81455a4ee9a3185f125ebf8cec325f4ed2e501d 100644
 --- a/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java
 +++ b/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java
 @@ -17,8 +17,14 @@ public class CraftWorldInfo implements WorldInfo {
@@ -100,7 +100,7 @@ index 5d655d6cd3e23e0287069f8bdf77601487e862fd..cf57c6e9ce63f7b1d95d91ead2453409
 +    private final net.minecraft.core.RegistryAccess.Frozen registryAccess;
  
 -    public CraftWorldInfo(ServerLevelData worldDataServer, LevelStorageSource.LevelStorageAccess session, World.Environment environment, DimensionType dimensionManager) {
-+    public CraftWorldInfo(ServerLevelData worldDataServer, LevelStorageSource.LevelStorageAccess session, World.Environment environment, DimensionType dimensionManager, net.minecraft.world.level.chunk.ChunkGenerator chunkGenerator, net.minecraft.core.RegistryAccess.Frozen registryAccess) {
++    public CraftWorldInfo(PrimaryLevelData worldDataServer, LevelStorageSource.LevelStorageAccess session, World.Environment environment, DimensionType dimensionManager, net.minecraft.world.level.chunk.ChunkGenerator chunkGenerator, net.minecraft.core.RegistryAccess.Frozen registryAccess) {
 +        this.registryAccess = registryAccess;
 +        this.vanillaChunkGenerator = chunkGenerator;
 +        // Paper end

patches/server/1058-Add-FeatureFlag-API.patch

@@ -0,0 +1,395 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 29 May 2024 19:50:21 -0700
+Subject: [PATCH] Add FeatureFlag API
+
+
+diff --git a/src/main/java/io/papermc/paper/world/flag/PaperFeatureDependent.java b/src/main/java/io/papermc/paper/world/flag/PaperFeatureDependent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c6fd2e8a570ac474dd1751929137280c52d79e78
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/world/flag/PaperFeatureDependent.java
+@@ -0,0 +1,17 @@
++package io.papermc.paper.world.flag;
++
++import java.util.Set;
++import net.minecraft.world.flag.FeatureElement;
++import org.bukkit.FeatureFlag;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.Unmodifiable;
++
++public interface PaperFeatureDependent extends FeatureDependant {
++
++    <M extends FeatureElement> M getHandle();
++
++    @Override
++    default @Unmodifiable @NonNull Set<FeatureFlag> requiredFeatures() {
++        return PaperFeatureFlagProviderImpl.fromNms(this.getHandle().requiredFeatures());
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/world/flag/PaperFeatureFlagProviderImpl.java b/src/main/java/io/papermc/paper/world/flag/PaperFeatureFlagProviderImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..d58b650fcafd04d00a92005ca8576d314535ce32
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/world/flag/PaperFeatureFlagProviderImpl.java
+@@ -0,0 +1,53 @@
++package io.papermc.paper.world.flag;
++
++import com.google.common.collect.BiMap;
++import com.google.common.collect.ImmutableBiMap;
++import java.util.Collections;
++import java.util.HashSet;
++import java.util.Set;
++import net.minecraft.world.flag.FeatureElement;
++import net.minecraft.world.flag.FeatureFlagSet;
++import net.minecraft.world.flag.FeatureFlags;
++import org.bukkit.FeatureFlag;
++import org.bukkit.craftbukkit.entity.CraftEntityType;
++import org.bukkit.craftbukkit.entity.CraftEntityTypes;
++import org.bukkit.craftbukkit.potion.CraftPotionType;
++import org.bukkit.craftbukkit.util.CraftMagicNumbers;
++import org.bukkit.entity.EntityType;
++import org.bukkit.potion.PotionType;
++
++public class PaperFeatureFlagProviderImpl implements FeatureFlagProvider {
++
++    public static final BiMap<FeatureFlag, net.minecraft.world.flag.FeatureFlag> FLAGS = ImmutableBiMap.of(
++        FeatureFlag.VANILLA, FeatureFlags.VANILLA,
++        FeatureFlag.BUNDLE, FeatureFlags.BUNDLE,
++        FeatureFlag.TRADE_REBALANCE, FeatureFlags.TRADE_REBALANCE
++    );
++
++    @Override
++    public Set<FeatureFlag> requiredFeatures(final FeatureDependant dependant) {
++        final FeatureFlagSet requiredFeatures = getFeatureElement(dependant).requiredFeatures();
++        return fromNms(requiredFeatures);
++    }
++
++    public static Set<FeatureFlag> fromNms(final FeatureFlagSet flagSet) {
++        final Set<FeatureFlag> flags = new HashSet<>();
++        for (final net.minecraft.world.flag.FeatureFlag nmsFlag : FeatureFlags.REGISTRY.names.values()) {
++            if (flagSet.contains(nmsFlag)) {
++                flags.add(FLAGS.inverse().get(nmsFlag));
++            }
++        }
++        return Collections.unmodifiableSet(flags);
++    }
++
++    static FeatureElement getFeatureElement(final FeatureDependant dependant) {
++        if (dependant instanceof final EntityType entityType) {
++            // TODO remove when EntityType is server-backed
++            return CraftEntityType.bukkitToMinecraft(entityType);
++        } else if (dependant instanceof final PotionType potionType) {
++            return CraftPotionType.bukkitToMinecraft(potionType);
++        } else {
++            throw new IllegalArgumentException(dependant + " is not a valid feature dependant");
++        }
++    }
++}
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftFeatureFlag.java b/src/main/java/org/bukkit/craftbukkit/CraftFeatureFlag.java
+deleted file mode 100644
+index da90e5c84a0cc4505a5fff0ed278a905978c6ce2..0000000000000000000000000000000000000000
+--- a/src/main/java/org/bukkit/craftbukkit/CraftFeatureFlag.java
++++ /dev/null
+@@ -1,51 +0,0 @@
+-package org.bukkit.craftbukkit;
+-
+-import java.util.HashSet;
+-import java.util.Set;
+-import net.minecraft.resources.ResourceLocation;
+-import net.minecraft.world.flag.FeatureFlagSet;
+-import net.minecraft.world.flag.FeatureFlags;
+-import org.bukkit.FeatureFlag;
+-import org.bukkit.NamespacedKey;
+-import org.bukkit.craftbukkit.util.CraftNamespacedKey;
+-import org.jetbrains.annotations.NotNull;
+-
+-public class CraftFeatureFlag implements FeatureFlag {
+-
+-    private final NamespacedKey namespacedKey;
+-    private final net.minecraft.world.flag.FeatureFlag featureFlag;
+-
+-    public CraftFeatureFlag(ResourceLocation minecraftKey, net.minecraft.world.flag.FeatureFlag featureFlag) {
+-        this.namespacedKey = CraftNamespacedKey.fromMinecraft(minecraftKey);
+-        this.featureFlag = featureFlag;
+-    }
+-
+-    public net.minecraft.world.flag.FeatureFlag getHandle() {
+-        return this.featureFlag;
+-    }
+-
+-    @NotNull
+-    @Override
+-    public NamespacedKey getKey() {
+-        return this.namespacedKey;
+-    }
+-
+-    @Override
+-    public String toString() {
+-        return "CraftFeatureFlag{key=" + this.getKey() + ",keyUniverse=" + this.getHandle().universe.toString() + "}";
+-    }
+-
+-    public static Set<CraftFeatureFlag> getFromNMS(FeatureFlagSet featureFlagSet) {
+-        Set<CraftFeatureFlag> set = new HashSet<>();
+-        FeatureFlags.REGISTRY.names.forEach((minecraftkey, featureflag) -> {
+-            if (featureFlagSet.contains(featureflag)) {
+-                set.add(new CraftFeatureFlag(minecraftkey, featureflag));
+-            }
+-        });
+-        return set;
+-    }
+-
+-    public static CraftFeatureFlag getFromNMS(NamespacedKey namespacedKey) {
+-        return FeatureFlags.REGISTRY.names.entrySet().stream().filter(entry -> CraftNamespacedKey.fromMinecraft(entry.getKey()).equals(namespacedKey)).findFirst().map(entry -> new CraftFeatureFlag(entry.getKey(), entry.getValue())).orElse(null);
+-    }
+-}
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+index 284234fcdd15c4c7a4567c7c887d47bf0b7967f4..c9ecec5da937bc5458f69736b68ff6ae50aa5ebc 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+@@ -558,4 +558,11 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+         return !this.getHandle().noCollision(aabb);
+     }
+     // Paper end
++
++    // Paper start - feature flag API
++    @Override
++    public java.util.Set<org.bukkit.FeatureFlag> getFeatureFlags() {
++        return io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl.fromNms(this.getHandle().enabledFeatures());
++    }
++    // Paper end - feature flag API
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 90d4834f97d3ba996d46493246b1947511553424..cd3381d8225e0322b3e285b3c4aa0a1265a91cc0 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -2372,10 +2372,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+         return this.persistentDataContainer;
+     }
+ 
+-    @Override
+-    public Set<FeatureFlag> getFeatureFlags() {
+-        return CraftFeatureFlag.getFromNMS(this.getHandle().enabledFeatures()).stream().map(FeatureFlag.class::cast).collect(Collectors.toUnmodifiableSet());
+-    }
++    // Paper - replace feature flag API
+ 
+     public void storeBukkitValues(CompoundTag c) {
+         if (!this.persistentDataContainer.isEmpty()) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockType.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockType.java
+index 785d3fe4929e008d4150f3ecab258fd5b6d7cdaf..978e602c38d66c1ac219ffdfe82f9fc777a6ad26 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockType.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockType.java
+@@ -33,7 +33,7 @@ import org.bukkit.craftbukkit.util.Handleable;
+ import org.bukkit.inventory.ItemType;
+ import org.jetbrains.annotations.NotNull;
+ 
+-public class CraftBlockType<B extends BlockData> implements BlockType.Typed<B>, Handleable<Block> {
++public class CraftBlockType<B extends BlockData> implements BlockType.Typed<B>, Handleable<Block>, io.papermc.paper.world.flag.PaperFeatureDependent { // Paper - feature flag API
+ 
+     private final NamespacedKey key;
+     private final Block block;
+diff --git a/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java b/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java
+index c81455a4ee9a3185f125ebf8cec325f4ed2e501d..8d962b055bd6574df7eb5510dd0efd67f579d84a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java
++++ b/src/main/java/org/bukkit/craftbukkit/generator/CraftWorldInfo.java
+@@ -17,6 +17,7 @@ public class CraftWorldInfo implements WorldInfo {
+     private final long seed;
+     private final int minHeight;
+     private final int maxHeight;
++    private final net.minecraft.world.flag.FeatureFlagSet enabledFeatures; // Paper - feature flag API
+     // Paper start
+     private final net.minecraft.world.level.chunk.ChunkGenerator vanillaChunkGenerator;
+     private final net.minecraft.core.RegistryAccess.Frozen registryAccess;
+@@ -31,6 +32,7 @@ public class CraftWorldInfo implements WorldInfo {
+         this.seed = ((PrimaryLevelData) worldDataServer).worldGenOptions().seed();
+         this.minHeight = dimensionManager.minY();
+         this.maxHeight = dimensionManager.minY() + dimensionManager.height();
++        this.enabledFeatures = worldDataServer.enabledFeatures(); // Paper - feature flag API
+     }
+ 
+     @Override
+@@ -92,4 +94,11 @@ public class CraftWorldInfo implements WorldInfo {
+         };
+     }
+     // Paper end
++
++    // Paper start - feature flag API
++    @Override
++    public java.util.Set<org.bukkit.FeatureFlag> getFeatureFlags() {
++        return io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl.fromNms(this.enabledFeatures);
++    }
++    // Paper end - feature flag API
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java
+index 450c63c31d2f5d056d989aa00452231f50c8224d..b9d9f1df2720c301915c8b07c0bdc12970128324 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemType.java
+@@ -36,7 +36,7 @@ import org.bukkit.inventory.meta.ItemMeta;
+ import org.jetbrains.annotations.NotNull;
+ import org.jetbrains.annotations.Nullable;
+ 
+-public class CraftItemType<M extends ItemMeta> implements ItemType.Typed<M>, Handleable<Item> {
++public class CraftItemType<M extends ItemMeta> implements ItemType.Typed<M>, Handleable<Item>, io.papermc.paper.world.flag.PaperFeatureDependent { // Paper - feature flag API
+ 
+     private final NamespacedKey key;
+     private final Item item;
+diff --git a/src/main/java/org/bukkit/craftbukkit/packs/CraftDataPack.java b/src/main/java/org/bukkit/craftbukkit/packs/CraftDataPack.java
+index 9525a7d4602b9b98dcc5e5e60dbcb628a656ae53..a0c0ad832726dcf9c8c25c1cfce2a6ddf770bf0f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/packs/CraftDataPack.java
++++ b/src/main/java/org/bukkit/craftbukkit/packs/CraftDataPack.java
+@@ -11,7 +11,7 @@ import net.minecraft.util.InclusiveRange;
+ import org.bukkit.Bukkit;
+ import org.bukkit.FeatureFlag;
+ import org.bukkit.NamespacedKey;
+-import org.bukkit.craftbukkit.CraftFeatureFlag;
++// import org.bukkit.craftbukkit.CraftFeatureFlag; // Paper - replace feature flag API
+ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.craftbukkit.util.CraftChatMessage;
+ import org.bukkit.packs.DataPack;
+@@ -98,7 +98,7 @@ public class CraftDataPack implements DataPack {
+ 
+     @Override
+     public Set<FeatureFlag> getRequestedFeatures() {
+-        return CraftFeatureFlag.getFromNMS(this.getHandle().getRequestedFeatures()).stream().map(FeatureFlag.class::cast).collect(Collectors.toUnmodifiableSet());
++        return io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl.fromNms(this.getHandle().getRequestedFeatures()); // Paper - replace feature flag API
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionEffectType.java b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionEffectType.java
+index 6cf790c9fa23ea313423fdaeb7c181bf530828c6..0bcb9df1103050441f8922a688b163dc97c04591 100644
+--- a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionEffectType.java
++++ b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionEffectType.java
+@@ -13,7 +13,7 @@ import org.bukkit.potion.PotionEffectType;
+ import org.bukkit.potion.PotionEffectTypeCategory;
+ import org.jetbrains.annotations.NotNull;
+ 
+-public class CraftPotionEffectType extends PotionEffectType implements Handleable<MobEffect> {
++public class CraftPotionEffectType extends PotionEffectType implements Handleable<MobEffect>, io.papermc.paper.world.flag.PaperFeatureDependent { // Paper - feature flag API
+ 
+     public static PotionEffectType minecraftHolderToBukkit(Holder<MobEffect> minecraft) {
+         return CraftPotionEffectType.minecraftToBukkit(minecraft.value());
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+index 28dbe30a98a6730839949bc9a6a90b78619ff84d..7d32c032b63b9c4674489b30c845fe2de8275808 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
++++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+@@ -47,7 +47,7 @@ import org.bukkit.advancement.Advancement;
+ import org.bukkit.attribute.Attribute;
+ import org.bukkit.attribute.AttributeModifier;
+ import org.bukkit.block.data.BlockData;
+-import org.bukkit.craftbukkit.CraftFeatureFlag;
++// import org.bukkit.craftbukkit.CraftFeatureFlag; // Paper
+ import org.bukkit.craftbukkit.CraftRegistry;
+ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.craftbukkit.attribute.CraftAttribute;
+@@ -455,11 +455,7 @@ public final class CraftMagicNumbers implements UnsafeValues {
+         return CraftAttribute.bukkitToMinecraft(attribute).getDescriptionId();
+     }
+ 
+-    @Override
+-    public FeatureFlag getFeatureFlag(NamespacedKey namespacedKey) {
+-        Preconditions.checkArgument(namespacedKey != null, "NamespaceKey cannot be null");
+-        return CraftFeatureFlag.getFromNMS(namespacedKey);
+-    }
++    // Paper - replace feature flag API
+ 
+     @Override
+     public PotionType.InternalPotionData getInternalPotionData(NamespacedKey namespacedKey) {
+diff --git a/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlagProvider b/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlagProvider
+new file mode 100644
+index 0000000000000000000000000000000000000000..c3e6b96013f6dd0b784bd867196552d97f3d8685
+--- /dev/null
++++ b/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlagProvider
+@@ -0,0 +1 @@
++io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl
+diff --git a/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlags$FeatureFlagProvider b/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlags$FeatureFlagProvider
+new file mode 100644
+index 0000000000000000000000000000000000000000..c3e6b96013f6dd0b784bd867196552d97f3d8685
+--- /dev/null
++++ b/src/main/resources/META-INF/services/io.papermc.paper.world.flag.FeatureFlags$FeatureFlagProvider
+@@ -0,0 +1 @@
++io.papermc.paper.world.flag.PaperFeatureFlagProviderImpl
+diff --git a/src/test/java/io/papermc/paper/world/flag/FeatureFlagTest.java b/src/test/java/io/papermc/paper/world/flag/FeatureFlagTest.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..174efed9d0352066a146acb4ec0554d46f81df21
+--- /dev/null
++++ b/src/test/java/io/papermc/paper/world/flag/FeatureFlagTest.java
+@@ -0,0 +1,79 @@
++package io.papermc.paper.world.flag;
++
++import io.papermc.paper.adventure.PaperAdventure;
++import io.papermc.paper.registry.PaperRegistries;
++import io.papermc.paper.registry.RegistryAccess;
++import io.papermc.paper.registry.RegistryKey;
++import java.util.HashSet;
++import java.util.Set;
++import net.kyori.adventure.key.Key;
++import net.minecraft.core.registries.Registries;
++import net.minecraft.resources.ResourceKey;
++import net.minecraft.resources.ResourceLocation;
++import net.minecraft.world.flag.FeatureElement;
++import net.minecraft.world.flag.FeatureFlagSet;
++import net.minecraft.world.flag.FeatureFlags;
++import org.bukkit.FeatureFlag;
++import org.bukkit.Keyed;
++import org.bukkit.support.AbstractTestingBase;
++import org.junit.jupiter.api.Test;
++import org.junit.jupiter.params.ParameterizedTest;
++import org.junit.jupiter.params.provider.MethodSource;
++
++import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
++import static org.junit.jupiter.api.Assertions.assertEquals;
++import static org.junit.jupiter.api.Assertions.assertInstanceOf;
++import static org.junit.jupiter.api.Assertions.assertNotNull;
++import static org.junit.jupiter.api.Assertions.fail;
++
++class FeatureFlagTest extends AbstractTestingBase {
++
++    @Test
++    void testFeatureFlagParity() {
++        final Set<ResourceLocation> locations = new HashSet<>();
++        for (final FeatureFlag flag : FeatureFlag.ALL_FLAGS.values()) {
++            locations.add(PaperAdventure.asVanilla(flag.getKey()));
++        }
++        FeatureFlags.REGISTRY.fromNames(locations, unknown -> {
++            fail("Unknown api feature flag: " + unknown);
++        });
++
++        for (final ResourceLocation nmsFlag : allNames()) {
++            assertNotNull(FeatureFlag.ALL_FLAGS.value(Key.key(nmsFlag.toString())), "can't find api flag for " + nmsFlag);
++        }
++    }
++
++    @Test
++    void testFeatureFlagConversion() {
++        assertEquals(allNames().size(), PaperFeatureFlagProviderImpl.FLAGS.size());
++        for (final FeatureFlag featureFlag : PaperFeatureFlagProviderImpl.FLAGS.keySet()) {
++            final net.minecraft.world.flag.FeatureFlag nmsFlag = PaperFeatureFlagProviderImpl.FLAGS.get(featureFlag);
++            final ResourceLocation nmsFlagName = FeatureFlags.REGISTRY.toNames(FeatureFlagSet.of(nmsFlag)).iterator().next();
++            assertEquals(nmsFlagName.toString(), featureFlag.key().asString());
++        }
++    }
++
++    static Set<ResourceLocation> allNames() {
++        return FeatureFlags.REGISTRY.toNames(FeatureFlags.REGISTRY.allFlags());
++    }
++
++    @SuppressWarnings({"rawtypes", "unchecked"})
++    static Set<RegistryKey<?>> featureFilteredRegistries() {
++        final Set<RegistryKey<?>> registryKeys = new HashSet<>();
++        for (final ResourceKey filteredRegistry : FeatureElement.FILTERED_REGISTRIES) {
++            if (filteredRegistry == Registries.MENU) continue; // not applicable atm
++            registryKeys.add(PaperRegistries.registryFromNms(filteredRegistry));
++        }
++        return registryKeys;
++    }
++
++    @MethodSource("featureFilteredRegistries")
++    @ParameterizedTest
++    <T extends Keyed> void testFeatureDependent(final RegistryKey<T> registryKey) {
++        final org.bukkit.Registry<T> registry = RegistryAccess.registryAccess().getRegistry(registryKey);
++        final T anyElement = registry.iterator().next();
++        assertInstanceOf(FeatureDependant.class, anyElement, "Registry " + registryKey + " doesn't have feature dependent elements");
++        final FeatureDependant dependant = ((FeatureDependant) anyElement);
++        assertDoesNotThrow(dependant::requiredFeatures, "Failed to get required features for " + anyElement + " in " + registryKey);
++    }
++}