Move CraftBukkit per-file patches

By: Initial <noreply+automated@papermc.io>

paper-server/patches/sources/net/minecraft/commands/CommandDispatcher.patch

@@ -0,0 +1,197 @@
+--- a/net/minecraft/commands/CommandDispatcher.java
++++ b/net/minecraft/commands/CommandDispatcher.java
+@@ -139,6 +139,14 @@
+ import net.minecraft.world.level.GameRules;
+ import org.slf4j.Logger;
+ 
++// CraftBukkit start
++import com.google.common.base.Joiner;
++import java.util.Collection;
++import java.util.LinkedHashSet;
++import org.bukkit.event.player.PlayerCommandSendEvent;
++import org.bukkit.event.server.ServerCommandEvent;
++// CraftBukkit end
++
+ public class CommandDispatcher {
+ 
+     private static final ThreadLocal<ExecutionContext<CommandListenerWrapper>> CURRENT_EXECUTION_CONTEXT = new ThreadLocal();
+@@ -151,6 +159,7 @@
+     private final com.mojang.brigadier.CommandDispatcher<CommandListenerWrapper> dispatcher = new com.mojang.brigadier.CommandDispatcher();
+ 
+     public CommandDispatcher(CommandDispatcher.ServerType commanddispatcher_servertype, CommandBuildContext commandbuildcontext) {
++        this(); // CraftBukkit
+         CommandAdvancement.register(this.dispatcher);
+         CommandAttribute.register(this.dispatcher, commandbuildcontext);
+         CommandExecute.register(this.dispatcher, commandbuildcontext);
+@@ -252,6 +261,11 @@
+             CommandPublish.register(this.dispatcher);
+         }
+ 
++        // CraftBukkit start
++    }
++
++    public CommandDispatcher() {
++        // CraftBukkkit end
+         this.dispatcher.setConsumer(ExecutionCommandSource.resultConsumer());
+     }
+ 
+@@ -262,18 +276,65 @@
+         return new ParseResults(commandcontextbuilder1, parseresults.getReader(), parseresults.getExceptions());
+     }
+ 
++    // CraftBukkit start
++    public void dispatchServerCommand(CommandListenerWrapper sender, String command) {
++        Joiner joiner = Joiner.on(" ");
++        if (command.startsWith("/")) {
++            command = command.substring(1);
++        }
++
++        ServerCommandEvent event = new ServerCommandEvent(sender.getBukkitSender(), command);
++        org.bukkit.Bukkit.getPluginManager().callEvent(event);
++        if (event.isCancelled()) {
++            return;
++        }
++        command = event.getCommand();
++
++        String[] args = command.split(" ");
++
++        String cmd = args[0];
++        if (cmd.startsWith("minecraft:")) cmd = cmd.substring("minecraft:".length());
++        if (cmd.startsWith("bukkit:")) cmd = cmd.substring("bukkit:".length());
++
++        // Block disallowed commands
++        if (cmd.equalsIgnoreCase("stop") || cmd.equalsIgnoreCase("kick") || cmd.equalsIgnoreCase("op")
++                || cmd.equalsIgnoreCase("deop") || cmd.equalsIgnoreCase("ban") || cmd.equalsIgnoreCase("ban-ip")
++                || cmd.equalsIgnoreCase("pardon") || cmd.equalsIgnoreCase("pardon-ip") || cmd.equalsIgnoreCase("reload")) {
++            return;
++        }
++
++        // Handle vanilla commands;
++        if (sender.getLevel().getCraftServer().getCommandBlockOverride(args[0])) {
++            args[0] = "minecraft:" + args[0];
++        }
++
++        String newCommand = joiner.join(args);
++        this.performPrefixedCommand(sender, newCommand, newCommand);
++    }
++    // CraftBukkit end
++
+     public void performPrefixedCommand(CommandListenerWrapper commandlistenerwrapper, String s) {
++        // CraftBukkit start
++        this.performPrefixedCommand(commandlistenerwrapper, s, s);
++    }
++
++    public void performPrefixedCommand(CommandListenerWrapper commandlistenerwrapper, String s, String label) {
+         s = s.startsWith("/") ? s.substring(1) : s;
+-        this.performCommand(this.dispatcher.parse(s, commandlistenerwrapper), s);
++        this.performCommand(this.dispatcher.parse(s, commandlistenerwrapper), s, label);
++        // CraftBukkit end
+     }
+ 
+     public void performCommand(ParseResults<CommandListenerWrapper> parseresults, String s) {
++        this.performCommand(parseresults, s, s);
++    }
++
++    public void performCommand(ParseResults<CommandListenerWrapper> parseresults, String s, String label) { // CraftBukkit
+         CommandListenerWrapper commandlistenerwrapper = (CommandListenerWrapper) parseresults.getContext().getSource();
+ 
+         Profiler.get().push(() -> {
+             return "/" + s;
+         });
+-        ContextChain<CommandListenerWrapper> contextchain = finishParsing(parseresults, s, commandlistenerwrapper);
++        ContextChain<CommandListenerWrapper> contextchain = finishParsing(parseresults, s, commandlistenerwrapper, label); // CraftBukkit
+ 
+         try {
+             if (contextchain != null) {
+@@ -307,7 +368,7 @@
+     }
+ 
+     @Nullable
+-    private static ContextChain<CommandListenerWrapper> finishParsing(ParseResults<CommandListenerWrapper> parseresults, String s, CommandListenerWrapper commandlistenerwrapper) {
++    private static ContextChain<CommandListenerWrapper> finishParsing(ParseResults<CommandListenerWrapper> parseresults, String s, CommandListenerWrapper commandlistenerwrapper, String label) { // CraftBukkit
+         try {
+             validateParseResults(parseresults);
+             return (ContextChain) ContextChain.tryFlatten(parseresults.getContext().build(s)).orElseThrow(() -> {
+@@ -318,7 +379,7 @@
+             if (commandsyntaxexception.getInput() != null && commandsyntaxexception.getCursor() >= 0) {
+                 int i = Math.min(commandsyntaxexception.getInput().length(), commandsyntaxexception.getCursor());
+                 IChatMutableComponent ichatmutablecomponent = IChatBaseComponent.empty().withStyle(EnumChatFormat.GRAY).withStyle((chatmodifier) -> {
+-                    return chatmodifier.withClickEvent(new ChatClickable(ChatClickable.EnumClickAction.SUGGEST_COMMAND, "/" + s));
++                    return chatmodifier.withClickEvent(new ChatClickable(ChatClickable.EnumClickAction.SUGGEST_COMMAND, label)); // CraftBukkit
+                 });
+ 
+                 if (i > 10) {
+@@ -368,7 +429,7 @@
+ 
+                 executioncontext1.close();
+             } finally {
+-                CommandDispatcher.CURRENT_EXECUTION_CONTEXT.set((Object) null);
++                CommandDispatcher.CURRENT_EXECUTION_CONTEXT.set(null); // CraftBukkit - decompile error
+             }
+         } else {
+             consumer.accept(executioncontext);
+@@ -377,11 +438,36 @@
+     }
+ 
+     public void sendCommands(EntityPlayer entityplayer) {
+-        Map<CommandNode<CommandListenerWrapper>, CommandNode<ICompletionProvider>> map = Maps.newHashMap();
++        // CraftBukkit start
++        // Register Vanilla commands into builtRoot as before
++        Map<CommandNode<CommandListenerWrapper>, CommandNode<ICompletionProvider>> map = Maps.newIdentityHashMap(); // Use identity to prevent aliasing issues
++        RootCommandNode vanillaRoot = new RootCommandNode();
++
++        RootCommandNode<CommandListenerWrapper> vanilla = entityplayer.server.vanillaCommandDispatcher.getDispatcher().getRoot();
++        map.put(vanilla, vanillaRoot);
++        this.fillUsableCommands(vanilla, vanillaRoot, entityplayer.createCommandSourceStack(), (Map) map);
++
++        // Now build the global commands in a second pass
+         RootCommandNode<ICompletionProvider> rootcommandnode = new RootCommandNode();
+ 
+         map.put(this.dispatcher.getRoot(), rootcommandnode);
+         this.fillUsableCommands(this.dispatcher.getRoot(), rootcommandnode, entityplayer.createCommandSourceStack(), map);
++
++        Collection<String> bukkit = new LinkedHashSet<>();
++        for (CommandNode node : rootcommandnode.getChildren()) {
++            bukkit.add(node.getName());
++        }
++
++        PlayerCommandSendEvent event = new PlayerCommandSendEvent(entityplayer.getBukkitEntity(), new LinkedHashSet<>(bukkit));
++        event.getPlayer().getServer().getPluginManager().callEvent(event);
++
++        // Remove labels that were removed during the event
++        for (String orig : bukkit) {
++            if (!event.getCommands().contains(orig)) {
++                rootcommandnode.removeCommand(orig);
++            }
++        }
++        // CraftBukkit end
+         entityplayer.connection.send(new PacketPlayOutCommands(rootcommandnode));
+     }
+ 
+@@ -392,7 +478,7 @@
+             CommandNode<CommandListenerWrapper> commandnode2 = (CommandNode) iterator.next();
+ 
+             if (commandnode2.canUse(commandlistenerwrapper)) {
+-                ArgumentBuilder<ICompletionProvider, ?> argumentbuilder = commandnode2.createBuilder();
++                ArgumentBuilder argumentbuilder = commandnode2.createBuilder(); // CraftBukkit - decompile error
+ 
+                 argumentbuilder.requires((icompletionprovider) -> {
+                     return true;
+@@ -415,7 +501,7 @@
+                     argumentbuilder.redirect((CommandNode) map.get(argumentbuilder.getRedirect()));
+                 }
+ 
+-                CommandNode<ICompletionProvider> commandnode3 = argumentbuilder.build();
++                CommandNode commandnode3 = argumentbuilder.build(); // CraftBukkit - decompile error
+ 
+                 map.put(commandnode2, commandnode3);
+                 commandnode1.addChild(commandnode3);
+@@ -481,7 +567,7 @@
+             }
+ 
+             private <T> HolderLookup.b.a<T> createLookup(final HolderLookup.b<T> holderlookup_b) {
+-                return new HolderLookup.b.a<T>(this) {
++                return new HolderLookup.b.a<T>() { // CraftBukkit - decompile error
+                     @Override
+                     public HolderLookup.b<T> parent() {
+                         return holderlookup_b;

paper-server/patches/sources/net/minecraft/commands/CommandListenerWrapper.patch

@@ -0,0 +1,63 @@
+--- a/net/minecraft/commands/CommandListenerWrapper.java
++++ b/net/minecraft/commands/CommandListenerWrapper.java
+@@ -46,6 +46,8 @@
+ import net.minecraft.world.phys.Vec2F;
+ import net.minecraft.world.phys.Vec3D;
+ 
++import com.mojang.brigadier.tree.CommandNode; // CraftBukkit
++
+ public class CommandListenerWrapper implements ExecutionCommandSource<CommandListenerWrapper>, ICompletionProvider {
+ 
+     public static final SimpleCommandExceptionType ERROR_NOT_PLAYER = new SimpleCommandExceptionType(IChatBaseComponent.translatable("permissions.requires.player"));
+@@ -65,6 +67,7 @@
+     private final Vec2F rotation;
+     private final CommandSigningContext signingContext;
+     private final TaskChainer chatMessageChainer;
++    public volatile CommandNode currentCommand; // CraftBukkit
+ 
+     public CommandListenerWrapper(ICommandListener icommandlistener, Vec3D vec3d, Vec2F vec2f, WorldServer worldserver, int i, String s, IChatBaseComponent ichatbasecomponent, MinecraftServer minecraftserver, @Nullable Entity entity) {
+         this(icommandlistener, vec3d, vec2f, worldserver, i, s, ichatbasecomponent, minecraftserver, entity, false, CommandResultCallback.EMPTY, ArgumentAnchor.Anchor.FEET, CommandSigningContext.ANONYMOUS, TaskChainer.immediate(minecraftserver));
+@@ -171,9 +174,23 @@
+ 
+     @Override
+     public boolean hasPermission(int i) {
++        // CraftBukkit start
++        CommandNode currentCommand = this.currentCommand;
++        if (currentCommand != null) {
++            return hasPermission(i, org.bukkit.craftbukkit.command.VanillaCommandWrapper.getPermission(currentCommand));
++        }
++        // CraftBukkit end
++
+         return this.permissionLevel >= i;
+     }
+ 
++    // CraftBukkit start
++    public boolean hasPermission(int i, String bukkitPermission) {
++        // World is null when loading functions
++        return ((getLevel() == null || !getLevel().getCraftServer().ignoreVanillaPermissions) && this.permissionLevel >= i) || getBukkitSender().hasPermission(bukkitPermission);
++    }
++    // CraftBukkit end
++
+     public Vec3D getPosition() {
+         return this.worldPosition;
+     }
+@@ -302,7 +319,7 @@
+             while (iterator.hasNext()) {
+                 EntityPlayer entityplayer = (EntityPlayer) iterator.next();
+ 
+-                if (entityplayer.commandSource() != this.source && this.server.getPlayerList().isOp(entityplayer.getGameProfile())) {
++                if (entityplayer.commandSource() != this.source && entityplayer.getBukkitEntity().hasPermission("minecraft.admin.command_feedback")) { // CraftBukkit
+                     entityplayer.sendSystemMessage(ichatmutablecomponent);
+                 }
+             }
+@@ -400,4 +417,10 @@
+     public boolean isSilent() {
+         return this.silent;
+     }
++
++    // CraftBukkit start
++    public org.bukkit.command.CommandSender getBukkitSender() {
++        return source.getBukkitSender(this);
++    }
++    // CraftBukkit end
+ }

paper-server/patches/sources/net/minecraft/commands/ICommandListener.patch

@@ -0,0 +1,23 @@
+--- a/net/minecraft/commands/ICommandListener.java
++++ b/net/minecraft/commands/ICommandListener.java
+@@ -22,6 +22,13 @@
+         public boolean shouldInformAdmins() {
+             return false;
+         }
++
++        // CraftBukkit start
++        @Override
++        public org.bukkit.command.CommandSender getBukkitSender(CommandListenerWrapper wrapper) {
++            throw new UnsupportedOperationException("Not supported yet.");
++        }
++        // CraftBukkit end
+     };
+ 
+     void sendSystemMessage(IChatBaseComponent ichatbasecomponent);
+@@ -35,4 +42,6 @@
+     default boolean alwaysAccepts() {
+         return false;
+     }
++
++    org.bukkit.command.CommandSender getBukkitSender(CommandListenerWrapper wrapper); // CraftBukkit
+ }

paper-server/patches/sources/net/minecraft/commands/arguments/ArgumentEntity.patch

@@ -0,0 +1,19 @@
+--- a/net/minecraft/commands/arguments/ArgumentEntity.java
++++ b/net/minecraft/commands/arguments/ArgumentEntity.java
+@@ -102,9 +102,15 @@
+     }
+ 
+     private EntitySelector parse(StringReader stringreader, boolean flag) throws CommandSyntaxException {
++        // CraftBukkit start
++        return parse(stringreader, flag, false);
++    }
++
++    public EntitySelector parse(StringReader stringreader, boolean flag, boolean overridePermissions) throws CommandSyntaxException {
++        // CraftBukkit end
+         boolean flag1 = false;
+         ArgumentParserSelector argumentparserselector = new ArgumentParserSelector(stringreader, flag);
+-        EntitySelector entityselector = argumentparserselector.parse();
++        EntitySelector entityselector = argumentparserselector.parse(overridePermissions); // CraftBukkit
+ 
+         if (entityselector.getMaxResults() > 1 && this.single) {
+             if (this.playersOnly) {

paper-server/patches/sources/net/minecraft/commands/arguments/blocks/ArgumentBlock.patch

@@ -0,0 +1,38 @@
+--- a/net/minecraft/commands/arguments/blocks/ArgumentBlock.java
++++ b/net/minecraft/commands/arguments/blocks/ArgumentBlock.java
+@@ -67,7 +67,7 @@
+     private final StringReader reader;
+     private final boolean forTesting;
+     private final boolean allowNbt;
+-    private final Map<IBlockState<?>, Comparable<?>> properties = Maps.newHashMap();
++    private final Map<IBlockState<?>, Comparable<?>> properties = Maps.newLinkedHashMap(); // CraftBukkit - stable
+     private final Map<String, String> vagueProperties = Maps.newHashMap();
+     private MinecraftKey id = MinecraftKey.withDefaultNamespace("");
+     @Nullable
+@@ -275,7 +275,7 @@
+         Iterator iterator = iblockstate.getPossibleValues().iterator();
+ 
+         while (iterator.hasNext()) {
+-            T t0 = (Comparable) iterator.next();
++            T t0 = (T) iterator.next(); // CraftBukkit - decompile error
+ 
+             if (t0 instanceof Integer integer) {
+                 suggestionsbuilder.suggest(integer);
+@@ -545,7 +545,7 @@
+         Optional<T> optional = iblockstate.getValue(s);
+ 
+         if (optional.isPresent()) {
+-            this.state = (IBlockData) this.state.setValue(iblockstate, (Comparable) optional.get());
++            this.state = (IBlockData) this.state.setValue(iblockstate, (T) optional.get()); // CraftBukkit - decompile error
+             this.properties.put(iblockstate, (Comparable) optional.get());
+         } else {
+             this.reader.setCursor(i);
+@@ -581,7 +581,7 @@
+     private static <T extends Comparable<T>> void appendProperty(StringBuilder stringbuilder, IBlockState<T> iblockstate, Comparable<?> comparable) {
+         stringbuilder.append(iblockstate.getName());
+         stringbuilder.append('=');
+-        stringbuilder.append(iblockstate.getName(comparable));
++        stringbuilder.append(iblockstate.getName((T) comparable)); // CraftBukkit - decompile error
+     }
+ 
+     public static record a(IBlockData blockState, Map<IBlockState<?>, Comparable<?>> properties, @Nullable NBTTagCompound nbt) {

paper-server/patches/sources/net/minecraft/commands/arguments/selector/ArgumentParserSelector.patch

@@ -0,0 +1,46 @@
+--- a/net/minecraft/commands/arguments/selector/ArgumentParserSelector.java
++++ b/net/minecraft/commands/arguments/selector/ArgumentParserSelector.java
+@@ -158,7 +158,7 @@
+             axisalignedbb = this.createAabb(this.deltaX == null ? 0.0D : this.deltaX, this.deltaY == null ? 0.0D : this.deltaY, this.deltaZ == null ? 0.0D : this.deltaZ);
+         }
+ 
+-        Function function;
++        Function<Vec3D, Vec3D> function; // CraftBukkit - decompile error
+ 
+         if (this.x == null && this.y == null && this.z == null) {
+             function = (vec3d) -> {
+@@ -215,8 +215,10 @@
+         };
+     }
+ 
+-    protected void parseSelector() throws CommandSyntaxException {
+-        this.usesSelectors = true;
++    // CraftBukkit start
++    protected void parseSelector(boolean overridePermissions) throws CommandSyntaxException {
++        this.usesSelectors = !overridePermissions;
++        // CraftBukkit end
+         this.suggestions = this::suggestSelector;
+         if (!this.reader.canRead()) {
+             throw ArgumentParserSelector.ERROR_MISSING_SELECTOR_TYPE.createWithContext(this.reader);
+@@ -505,6 +507,12 @@
+     }
+ 
+     public EntitySelector parse() throws CommandSyntaxException {
++        // CraftBukkit start
++        return parse(false);
++    }
++
++    public EntitySelector parse(boolean overridePermissions) throws CommandSyntaxException {
++        // CraftBukkit end
+         this.startPosition = this.reader.getCursor();
+         this.suggestions = this::suggestNameOrSelector;
+         if (this.reader.canRead() && this.reader.peek() == '@') {
+@@ -513,7 +521,7 @@
+             }
+ 
+             this.reader.skip();
+-            this.parseSelector();
++            this.parseSelector(overridePermissions); // CraftBukkit
+         } else {
+             this.parseNameOrUUID();
+         }

paper-server/patches/sources/net/minecraft/commands/arguments/selector/EntitySelector.patch

@@ -0,0 +1,11 @@
+--- a/net/minecraft/commands/arguments/selector/EntitySelector.java
++++ b/net/minecraft/commands/arguments/selector/EntitySelector.java
+@@ -93,7 +93,7 @@
+     }
+ 
+     private void checkPermissions(CommandListenerWrapper commandlistenerwrapper) throws CommandSyntaxException {
+-        if (this.usesSelector && !commandlistenerwrapper.hasPermission(2)) {
++        if (this.usesSelector && !commandlistenerwrapper.hasPermission(2, "minecraft.command.selector")) { // CraftBukkit
+             throw ArgumentEntity.ERROR_SELECTORS_NOT_ALLOWED.create();
+         }
+     }