Repackage patches

By: md_5 <git@md-5.net>

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

@@ -0,0 +1,150 @@
+--- a/net/minecraft/server/CommandDispatcher.java
++++ b/net/minecraft/server/CommandDispatcher.java
+@@ -19,12 +19,21 @@
+ import org.apache.logging.log4j.LogManager;
+ import org.apache.logging.log4j.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 Logger LOGGER = LogManager.getLogger();
+     private final com.mojang.brigadier.CommandDispatcher<CommandListenerWrapper> b = new com.mojang.brigadier.CommandDispatcher();
+ 
+     public CommandDispatcher(CommandDispatcher.ServerType commanddispatcher_servertype) {
++        this(); // CraftBukkit
+         CommandAdvancement.a(this.b);
+         CommandAttribute.a(this.b);
+         CommandExecute.a(this.b);
+@@ -105,14 +114,57 @@
+         }
+ 
+         this.b.findAmbiguities((commandnode, commandnode1, commandnode2, collection) -> {
+-            CommandDispatcher.LOGGER.warn("Ambiguity between arguments {} and {} with inputs: {}", this.b.getPath(commandnode1), this.b.getPath(commandnode2), collection);
++            // CommandDispatcher.LOGGER.warn("Ambiguity between arguments {} and {} with inputs: {}", this.b.getPath(commandnode1), this.b.getPath(commandnode2), collection); // CraftBukkit
+         });
+-        this.b.setConsumer((commandcontext, flag, i) -> {
+-            ((CommandListenerWrapper) commandcontext.getSource()).a(commandcontext, flag, i);
++    }
++
++    // CraftBukkit start
++    public CommandDispatcher() {
++        this.b.setConsumer((commandcontext, flag1, i) -> {
++            ((CommandListenerWrapper) commandcontext.getSource()).a(commandcontext, flag1, i);
+         });
+     }
+ 
++    public int 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 0;
++        }
++        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 0;
++        }
++
++        // Handle vanilla commands;
++        if (sender.getWorld().getServer().getCommandBlockOverride(args[0])) {
++            args[0] = "minecraft:" + args[0];
++        }
++
++        return this.a(sender, joiner.join(args));
++    }
++
+     public int a(CommandListenerWrapper commandlistenerwrapper, String s) {
++        return this.a(commandlistenerwrapper, s, s);
++    }
++
++    public int a(CommandListenerWrapper commandlistenerwrapper, String s, String label) {
++        // CraftBukkit end
+         StringReader stringreader = new StringReader(s);
+ 
+         if (stringreader.canRead() && stringreader.peek() == '/') {
+@@ -139,7 +191,7 @@
+                 if (commandsyntaxexception.getInput() != null && commandsyntaxexception.getCursor() >= 0) {
+                     int j = Math.min(commandsyntaxexception.getInput().length(), commandsyntaxexception.getCursor());
+                     IChatMutableComponent ichatmutablecomponent = (new ChatComponentText("")).a(EnumChatFormat.GRAY).format((chatmodifier) -> {
+-                        return chatmodifier.setChatClickable(new ChatClickable(ChatClickable.EnumClickAction.SUGGEST_COMMAND, s));
++                        return chatmodifier.setChatClickable(new ChatClickable(ChatClickable.EnumClickAction.SUGGEST_COMMAND, label)); // CraftBukkit
+                     });
+ 
+                     if (j > 10) {
+@@ -189,11 +241,36 @@
+     }
+ 
+     public void a(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.a().getRoot();
++        map.put(vanilla, vanillaRoot);
++        this.a(vanilla, vanillaRoot, entityplayer.getCommandListener(), (Map) map);
++
++        // Now build the global commands in a second pass
+         RootCommandNode<ICompletionProvider> rootcommandnode = new RootCommandNode();
+ 
+         map.put(this.b.getRoot(), rootcommandnode);
+         this.a(this.b.getRoot(), rootcommandnode, entityplayer.getCommandListener(), (Map) 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.playerConnection.sendPacket(new PacketPlayOutCommands(rootcommandnode));
+     }
+ 
+@@ -204,7 +281,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;
+@@ -227,7 +304,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);

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

@@ -0,0 +1,63 @@
+--- a/net/minecraft/server/CommandListenerWrapper.java
++++ b/net/minecraft/server/CommandListenerWrapper.java
+@@ -15,6 +15,8 @@
+ import java.util.stream.Stream;
+ import javax.annotation.Nullable;
+ 
++import com.mojang.brigadier.tree.CommandNode; // CraftBukkit
++
+ public class CommandListenerWrapper implements ICompletionProvider {
+ 
+     public static final SimpleCommandExceptionType a = new SimpleCommandExceptionType(new ChatMessage("permissions.requires.player"));
+@@ -32,6 +34,7 @@
+     private final ResultConsumer<CommandListenerWrapper> l;
+     private final ArgumentAnchor.Anchor m;
+     private final Vec2F n;
++    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, (commandcontext, flag, j) -> {
+@@ -128,9 +131,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.f >= i;
+     }
+ 
++    // CraftBukkit start
++    public boolean hasPermission(int i, String bukkitPermission) {
++        // World is null when loading functions
++        return ((getWorld() == null || !getWorld().getServer().ignoreVanillaPermissions) && this.f >= i) || getBukkitSender().hasPermission(bukkitPermission);
++    }
++    // CraftBukkit end
++
+     public Vec3D getPosition() {
+         return this.d;
+     }
+@@ -192,7 +209,7 @@
+             while (iterator.hasNext()) {
+                 EntityPlayer entityplayer = (EntityPlayer) iterator.next();
+ 
+-                if (entityplayer != this.base && this.i.getPlayerList().isOp(entityplayer.getProfile())) {
++                if (entityplayer != this.base && entityplayer.getBukkitEntity().hasPermission("minecraft.admin.command_feedback")) { // CraftBukkit
+                     entityplayer.sendMessage(ichatmutablecomponent, SystemUtils.b);
+                 }
+             }
+@@ -252,4 +269,10 @@
+     public IRegistryCustom q() {
+         return this.i.getCustomRegistry();
+     }
++
++    // CraftBukkit start
++    public org.bukkit.command.CommandSender getBukkitSender() {
++        return base.getBukkitSender(this);
++    }
++    // CraftBukkit end
+ }

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

@@ -0,0 +1,23 @@
+--- a/net/minecraft/server/ICommandListener.java
++++ b/net/minecraft/server/ICommandListener.java
+@@ -22,6 +22,13 @@
+         public boolean shouldBroadcastCommands() {
+             return false;
+         }
++
++        // CraftBukkit start
++        @Override
++        public org.bukkit.command.CommandSender getBukkitSender(CommandListenerWrapper wrapper) {
++            throw new UnsupportedOperationException("Not supported yet.");
++        }
++        // CraftBukkit end
+     };
+ 
+     void sendMessage(IChatBaseComponent ichatbasecomponent, UUID uuid);
+@@ -31,4 +38,6 @@
+     boolean shouldSendFailure();
+ 
+     boolean shouldBroadcastCommands();
++
++    org.bukkit.command.CommandSender getBukkitSender(CommandListenerWrapper wrapper); // CraftBukkit
+ }

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

@@ -0,0 +1,19 @@
+--- a/net/minecraft/server/ArgumentEntity.java
++++ b/net/minecraft/server/ArgumentEntity.java
+@@ -84,9 +84,15 @@
+     }
+ 
+     public EntitySelector parse(StringReader stringreader) throws CommandSyntaxException {
++        // CraftBukkit start
++        return parse(stringreader, false);
++    }
++
++    public EntitySelector parse(StringReader stringreader, boolean overridePermissions) throws CommandSyntaxException {
++        // CraftBukkit end
+         boolean flag = false;
+         ArgumentParserSelector argumentparserselector = new ArgumentParserSelector(stringreader);
+-        EntitySelector entityselector = argumentparserselector.parse();
++        EntitySelector entityselector = argumentparserselector.parse(overridePermissions); // CraftBukkit
+ 
+         if (entityselector.a() > 1 && this.h) {
+             if (this.i) {

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

@@ -0,0 +1,38 @@
+--- a/net/minecraft/server/ArgumentBlock.java
++++ b/net/minecraft/server/ArgumentBlock.java
+@@ -43,7 +43,7 @@
+     };
+     private final StringReader i;
+     private final boolean j;
+-    private final Map<IBlockState<?>, Comparable<?>> k = Maps.newHashMap();
++    private final Map<IBlockState<?>, Comparable<?>> k = Maps.newLinkedHashMap(); // CraftBukkit - stable
+     private final Map<String, String> l = Maps.newHashMap();
+     private MinecraftKey m = new MinecraftKey("");
+     private BlockStateList<Block, IBlockData> n;
+@@ -219,7 +219,7 @@
+         Iterator iterator = iblockstate.getValues().iterator();
+ 
+         while (iterator.hasNext()) {
+-            T t0 = (Comparable) iterator.next();
++            T t0 = (T) iterator.next(); // CraftBukkit - decompile error
+ 
+             if (t0 instanceof Integer) {
+                 suggestionsbuilder.suggest((Integer) t0);
+@@ -488,7 +488,7 @@
+         Optional<T> optional = iblockstate.b(s);
+ 
+         if (optional.isPresent()) {
+-            this.o = (IBlockData) this.o.set(iblockstate, (Comparable) optional.get());
++            this.o = (IBlockData) this.o.set(iblockstate, (T) optional.get()); // CraftBukkit - decompile error
+             this.k.put(iblockstate, optional.get());
+         } else {
+             this.i.setCursor(i);
+@@ -522,7 +522,7 @@
+     private static <T extends Comparable<T>> void a(StringBuilder stringbuilder, IBlockState<T> iblockstate, Comparable<?> comparable) {
+         stringbuilder.append(iblockstate.getName());
+         stringbuilder.append('=');
+-        stringbuilder.append(iblockstate.a(comparable));
++        stringbuilder.append(iblockstate.a((T) comparable)); // CraftBukkit - decompile error
+     }
+ 
+     public CompletableFuture<Suggestions> a(SuggestionsBuilder suggestionsbuilder, Tags<Block> tags) {

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

@@ -0,0 +1,46 @@
+--- a/net/minecraft/server/ArgumentParserSelector.java
++++ b/net/minecraft/server/ArgumentParserSelector.java
+@@ -127,7 +127,7 @@
+             axisalignedbb = this.a(this.v == null ? 0.0D : this.v, this.w == null ? 0.0D : this.w, this.x == null ? 0.0D : this.x);
+         }
+ 
+-        Function function;
++        Function<Vec3D, Vec3D> function; // CraftBukkit - decompile error
+ 
+         if (this.s == null && this.t == null && this.u == null) {
+             function = (vec3d) -> {
+@@ -188,8 +188,10 @@
+         };
+     }
+ 
+-    protected void parseSelector() throws CommandSyntaxException {
+-        this.checkPermissions = true;
++    // CraftBukkit start
++    protected void parseSelector(boolean overridePermissions) throws CommandSyntaxException {
++        this.checkPermissions = !overridePermissions;
++        // CraftBukkit end
+         this.G = this::d;
+         if (!this.l.canRead()) {
+             throw ArgumentParserSelector.d.createWithContext(this.l);
+@@ -443,6 +445,12 @@
+     }
+ 
+     public EntitySelector parse() throws CommandSyntaxException {
++        // CraftBukkit start
++        return parse(false);
++    }
++
++    public EntitySelector parse(boolean overridePermissions) throws CommandSyntaxException {
++        // CraftBukkit end
+         this.E = this.l.getCursor();
+         this.G = this::b;
+         if (this.l.canRead() && this.l.peek() == '@') {
+@@ -451,7 +459,7 @@
+             }
+ 
+             this.l.skip();
+-            this.parseSelector();
++            this.parseSelector(overridePermissions); // CraftBukkit
+         } else {
+             this.c();
+         }

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

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