Don't let an impermissible literal shadow an overlapping argument node

`CommandNode#getRelevantNodes` short-circuits to a literal whose name matches the next token regardless of whether the source can use it. `parseNodes` then skips that literal via canUse and, because the relevant-node set was the literal alone, never falls back to the argument siblings, making an argument node whose text overlaps the literal unreachable for any source lacking the literal's permission.

Add a source-aware `getRelevantNodes(StringReader, source)` overload that only short-circuits to the matched literal when the source can use it, otherwise falling back to the argument nodes. The permitted case is byte-for-byte unchanged (still returns the single literal), so literal priority is preserved.

Author: WouterGritter

src/main/java/com/mojang/brigadier/CommandDispatcher.java

@@ -297,7 +297,7 @@ private ParseResults<S> parseNodes(final CommandNode<S> node, final StringReader
         List<ParseResults<S>> potentials = null;
         final int cursor = originalReader.getCursor();
 
-        for (final CommandNode<S> child : node.getRelevantNodes(originalReader)) {
+        for (final CommandNode<S> child : node.getRelevantNodes(originalReader, source)) {
             if (!child.canUse(source)) {
                 continue;
             }

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

@@ -152,21 +152,32 @@ public Predicate<S> getRequirement() {
 
     public Collection<? extends CommandNode<S>> getRelevantNodes(final StringReader input) {
         if (literals.size() > 0) {
-            final int cursor = input.getCursor();
-            while (input.canRead() && input.peek() != ' ') {
-                input.skip();
-            }
-            final String text = input.getString().substring(cursor, input.getCursor());
-            input.setCursor(cursor);
-            final LiteralCommandNode<S> literal = literals.get(text);
+            final LiteralCommandNode<S> literal = getMatchingLiteral(input);
             if (literal != null) {
                 return Collections.singleton(literal);
-            } else {
-                return arguments.values();
             }
-        } else {
-            return arguments.values();
         }
+        return arguments.values();
+    }
+
+    public Collection<? extends CommandNode<S>> getRelevantNodes(final StringReader input, final S source) {
+        if (literals.size() > 0) {
+            final LiteralCommandNode<S> literal = getMatchingLiteral(input);
+            if (literal != null && literal.canUse(source)) {
+                return Collections.singleton(literal);
+            }
+        }
+        return arguments.values();
+    }
+
+    private LiteralCommandNode<S> getMatchingLiteral(final StringReader input) {
+        final int cursor = input.getCursor();
+        while (input.canRead() && input.peek() != ' ') {
+            input.skip();
+        }
+        final String text = input.getString().substring(cursor, input.getCursor());
+        input.setCursor(cursor);
+        return literals.get(text);
     }
 
     @Override

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

@@ -25,6 +25,7 @@
 
 import static com.mojang.brigadier.arguments.IntegerArgumentType.getInteger;
 import static com.mojang.brigadier.arguments.IntegerArgumentType.integer;
+import static com.mojang.brigadier.arguments.StringArgumentType.word;
 import static com.mojang.brigadier.builder.LiteralArgumentBuilder.literal;
 import static com.mojang.brigadier.builder.RequiredArgumentBuilder.argument;
 import static org.hamcrest.Matchers.equalTo;
@@ -123,6 +124,37 @@ public void testExecuteImpermissibleCommand() {
         }
     }
 
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testImpermissibleLiteralFallsBackToArgument() throws Exception {
+        final Command<Object> argCommand = mock(Command.class);
+        when(argCommand.run(any())).thenReturn(100);
+        subject.register(literal("foo")
+                .then(literal("bar").requires(s -> false).executes(command))
+                .then(argument("value", word()).executes(argCommand)));
+
+        // The source cannot use the "bar" literal, so "foo bar" must fall back to the <value> argument
+        // instead of failing because the impermissible literal shadowed it.
+        assertThat(subject.execute("foo bar", source), is(100));
+        verify(argCommand).run(any(CommandContext.class));
+        verify(command, never()).run(any(CommandContext.class));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testUsableLiteralTakesPriorityOverArgument() throws Exception {
+        final Command<Object> argCommand = mock(Command.class);
+        when(argCommand.run(any())).thenReturn(100);
+        subject.register(literal("foo")
+                .then(literal("bar").executes(command))
+                .then(argument("value", word()).executes(argCommand)));
+
+        // "bar" matches a usable literal, which must keep priority over the overlapping <value> argument.
+        assertThat(subject.execute("foo bar", source), is(42));
+        verify(command).run(any(CommandContext.class));
+        verify(argCommand, never()).run(any(CommandContext.class));
+    }
+
     @Test
     public void testExecuteEmptyCommand() {
         subject.register(literal(""));