Consider arguments when literal is impermissible

Fixes Mojang#87

Author: hugmanrique

src/main/java/com/mojang/brigadier/tree/CommandNode.java

@@ -15,10 +15,12 @@
 import com.mojang.brigadier.suggestion.Suggestions;
 import com.mojang.brigadier.suggestion.SuggestionsBuilder;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
@@ -189,7 +191,16 @@ public Collection<? extends CommandNode<S>> getRelevantNodes(final StringReader
             input.setCursor(cursor);
             final CommandNode<S> node = children.get(text);
             if (node instanceof LiteralCommandNode<?>) {
-                return Collections.singleton(node);
+                final int argumentsCount = arguments.size();
+                if (argumentsCount == 0) {
+                    return Collections.singletonList(node);
+                } else {
+                    final List<CommandNode<S>> nodes =
+                            new ArrayList<>(argumentsCount + 1);
+                    nodes.add(node); // literals have priority over arguments
+                    nodes.addAll(arguments.values());
+                    return nodes;
+                }
             } else {
                 return arguments.values();
             }

src/test/java/com/mojang/brigadier/CommandDispatcherTest.java

@@ -4,6 +4,7 @@
 package com.mojang.brigadier;
 
 import com.google.common.collect.Lists;
+import com.mojang.brigadier.arguments.StringArgumentType;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.context.CommandContextBuilder;
 import com.mojang.brigadier.context.StringRange;
@@ -302,6 +303,47 @@ public void testExecuteAmbiguiousParentSubcommandViaRedirect() throws Exception
         verify(command, never()).run(any());
     }
 
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testPreferExecuteLiteralOverArguments() throws Exception {
+        final Command<Object> literalCommand = mock(Command.class);
+        when(literalCommand.run(any())).thenReturn(100);
+
+        subject.register(
+            literal("test")
+                .then(
+                    argument("incorrect", StringArgumentType.word())
+                        .executes(command)
+                )
+                .then(
+                    literal("hello")
+                        .executes(literalCommand)
+                )
+        );
+
+        assertThat(subject.execute("test hello", source), is(100));
+        verify(literalCommand).run(any(CommandContext.class));
+        verify(command, never()).run(any());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testExecuteAmbiguousArgumentIfImpermissibleLiteral() throws Exception {
+        subject.register(literal("foo")
+            .then(
+                literal("bar")
+                    .requires(source -> false)
+            )
+            .then(
+                argument("argument", StringArgumentType.word())
+                    .executes(command)
+            )
+        );
+
+        assertThat(subject.execute("foo bar", source), is(42));
+        verify(command).run(any(CommandContext.class));
+    }
+
     @SuppressWarnings("unchecked")
     @Test
     public void testExecuteRedirectedMultipleTimes() throws Exception {