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

--- a/net/minecraft/commands/CommandDispatcher.java
+++ b/net/minecraft/commands/CommandDispatcher.java
@@ -107,6 +107,14 @@
 import net.minecraft.util.profiling.jfr.JvmProfiler;
 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 Logger LOGGER = LogUtils.getLogger();
@@ -118,6 +126,7 @@
     private final com.mojang.brigadier.CommandDispatcher<CommandListenerWrapper> dispatcher = new com.mojang.brigadier.CommandDispatcher();
 
     public CommandDispatcher(CommandDispatcher.ServerType commanddispatcher_servertype) {
+        this(); // CraftBukkit
         CommandAdvancement.register(this.dispatcher);
         CommandAttribute.register(this.dispatcher);
         CommandExecute.register(this.dispatcher);
@@ -204,17 +213,63 @@
         }
 
         this.dispatcher.findAmbiguities((commandnode, commandnode1, commandnode2, collection) -> {
-            CommandDispatcher.LOGGER.warn("Ambiguity between arguments {} and {} with inputs: {}", new Object[]{this.dispatcher.getPath(commandnode1), this.dispatcher.getPath(commandnode2), collection});
+            // CommandDispatcher.LOGGER.warn("Ambiguity between arguments {} and {} with inputs: {}", new Object[]{this.dispatcher.getPath(commandnode1), this.dispatcher.getPath(commandnode2), collection}); // CraftBukkit
         });
+        // CraftBukkit start
+    }
+
+    public CommandDispatcher() {
+        // CraftBukkkit end
         this.dispatcher.setConsumer((commandcontext, flag, i) -> {
             ((CommandListenerWrapper) commandcontext.getSource()).onCommandComplete(commandcontext, flag, i);
         });
     }
 
+    // CraftBukkit start
+    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.getLevel().getCraftServer().getCommandBlockOverride(args[0])) {
+            args[0] = "minecraft:" + args[0];
+        }
+
+        String newCommand = joiner.join(args);
+        return this.performCommand(sender, newCommand, newCommand, false);
+    }
+
     public int performCommand(CommandListenerWrapper commandlistenerwrapper, String s) {
+        return this.performCommand(commandlistenerwrapper, s, s, true);
+    }
+
+    public int performCommand(CommandListenerWrapper commandlistenerwrapper, String s, String label, boolean stripSlash) {
         StringReader stringreader = new StringReader(s);
 
-        if (stringreader.canRead() && stringreader.peek() == '/') {
+        if (stripSlash && stringreader.canRead() && stringreader.peek() == '/') {
+            // CraftBukkit end
             stringreader.skip();
         }
 
@@ -238,7 +293,7 @@
                 if (commandsyntaxexception.getInput() != null && commandsyntaxexception.getCursor() >= 0) {
                     int j = Math.min(commandsyntaxexception.getInput().length(), commandsyntaxexception.getCursor());
                     IChatMutableComponent ichatmutablecomponent = (new ChatComponentText("")).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 (j > 10) {
@@ -288,11 +343,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));
     }
 
@@ -303,7 +383,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;
@@ -326,7 +406,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);