Initial implementation of FlagsArgument (and other changes)

Changes:
- Implemented `FlagsArgument` (#483)
  - Moved var handles for `CommandNode` `children`,`literals`, and `arguments` to `CommandAPIHandler`
  - Added `FlagsArgumentCommon` FlagsArgumentRootNode` and `FlagsArgumentEndingNode` to handle the special node structure and parsing required
- Updated `CustomArgument`
  - All `AbstractArgument` builder methods are delegated to the base argument
  - Replaced `CommandAPIExecutor` parameter of `AbstractArgument#addArgumentNodes` to a `Function` to allow object that hold arguments to better control how those arguments are executed
- Added package `dev.jorel.commandapi.commandnodes` for class that extend `CommandNode` and related classes
- Tweaked some exceptions
  - `GreedyArgumentException`
    - Changed because the `FlagsArgument` is sometimes greedy - only greedy iff it has no terminal branches
    - Greedy arguments are now detected when `AbstractArgument#addArgumentNodes` returns an empty list
    - Tweaked the exception message
  - `DuplicateNodeNameException`
    - Changed because literal arguments can conflict with other nodes if they are listed
    - Now thrown when two listed arguments have the same node name
    - Added `UnnamedArgumentCommandNode` to make sure unlisted arguments do not conflict
    - Renamed `MultiLiteralCommandNode` to `NamedLiteralCommandNode` for use by listed `Literal` arguments
    - Tweaked the exception message

TODO:
- Clean up code
- Add tests
- Remove test commands in CommandAPIMain
- Add javadocs and documentation
- Hope Mojang/brigadier#144 is resolved, otherwise be annoyed :(

commandapi-core/src/main/java/dev/jorel/commandapi/AbstractArgumentTree.java

@@ -2,8 +2,6 @@
 
 import com.mojang.brigadier.tree.CommandNode;
 import dev.jorel.commandapi.arguments.AbstractArgument;
-import dev.jorel.commandapi.arguments.GreedyArgument;
-import dev.jorel.commandapi.exceptions.GreedyArgumentException;
 import dev.jorel.commandapi.exceptions.MissingCommandExecutorException;
 
 import java.util.ArrayList;
@@ -125,55 +123,34 @@ public List<List<String>> getBranchesAsStrings() {
  /**
  * Builds the Brigadier {@link CommandNode} structure for this argument tree.
  *
- * @param previousNodes  A List of {@link CommandNode}s to add this argument onto.
- * @param previousArguments  A List of CommandAPI arguments that came before this argument tree.
- * @param previousNonLiteralArgumentNames A List of Strings containing the node names that came before this argument.
- * @param <Source>  The Brigadier Source object for running commands.
+ * @param previousNodes A List of {@link CommandNode}s to add this argument onto.
+ * @param previousArguments A List of CommandAPI arguments that came before this argument tree.
+ * @param previousArgumentNames A List of Strings containing the node names that came before this argument.
+ * @param <Source> The Brigadier Source object for running commands.
  */
  public <Source> void buildBrigadierNode(
  List<CommandNode<Source>> previousNodes,
- List<Argument> previousArguments, List<String> previousNonLiteralArgumentNames
+ List<Argument> previousArguments, List<String> previousArgumentNames
  ) {
+ CommandAPIHandler<Argument, CommandSender, Source> handler = CommandAPIHandler.getInstance();
+
  // Check preconditions
- if (argument instanceof GreedyArgument && !arguments.isEmpty()) {
- // Argument is followed by at least some arguments
- throw new GreedyArgumentException(previousArguments, argument, getBranchesAsList());
- }
  if (!executor.hasAnyExecutors() && arguments.isEmpty()) {
  // If we don't have any executors then no branches is bad because this path can't be run at all
  throw new MissingCommandExecutorException(previousArguments, argument);
  }
 
  // Create node for this argument
- previousNodes = argument.addArgumentNodes(previousNodes, previousArguments, previousNonLiteralArgumentNames, executor);
+ previousNodes = argument.addArgumentNodes(previousNodes, previousArguments, previousArgumentNames,
+ executor.hasAnyExecutors() ? args -> handler.generateBrigadierCommand(args, executor) : null);
 
  // Add our branches as children to the node
  for (AbstractArgumentTree<?, Argument, CommandSender> child : arguments) {
  // We need a new list for each branch of the tree
  List<Argument> newPreviousArguments = new ArrayList<>(previousArguments);
- List<String> newPreviousArgumentNames = new ArrayList<>(previousNonLiteralArgumentNames);
+ List<String> newPreviousArgumentNames = new ArrayList<>(previousArgumentNames);
 
  child.buildBrigadierNode(previousNodes, newPreviousArguments, newPreviousArgumentNames);
  }
  }
-
- /**
- * @return A list of paths that represent the possible branches of this argument tree as Argument objects.
- */
- protected List<List<Argument>> getBranchesAsList() {
- if (arguments.isEmpty()) return List.of(List.of());
-
- List<List<Argument>> branchesList = new ArrayList<>();
-
- for (AbstractArgumentTree<?, Argument, CommandSender> branch : arguments) {
- for (List<Argument> subBranchList : branch.getBranchesAsList()) {
- List<Argument> newBranchList = new ArrayList<>();
- newBranchList.add(branch.argument);
- newBranchList.addAll(subBranchList);
- branchesList.add(newBranchList);
- }
- }
-
- return branchesList;
- }
 }

commandapi-core/src/main/java/dev/jorel/commandapi/AbstractCommandAPICommand.java

@@ -20,17 +20,17 @@
  *******************************************************************************/
 package dev.jorel.commandapi;
 
+import com.mojang.brigadier.Command;
 import com.mojang.brigadier.tree.CommandNode;
 import com.mojang.brigadier.tree.LiteralCommandNode;
 import dev.jorel.commandapi.arguments.AbstractArgument;
-import dev.jorel.commandapi.arguments.GreedyArgument;
-import dev.jorel.commandapi.exceptions.GreedyArgumentException;
 import dev.jorel.commandapi.exceptions.MissingCommandExecutorException;
 import dev.jorel.commandapi.exceptions.OptionalArgumentException;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.function.Function;
 
 /**
  * A builder used to create commands to be registered by the CommandAPI.
@@ -317,30 +317,19 @@ protected <Source> void createArgumentNodes(LiteralCommandNode<Source> rootNode)
  previousArguments.add(commandNames);
 
  // Add required arguments
+ Function<List<Argument>, Command<Source>> executorCreator = executor.hasAnyExecutors() ?
+ args -> handler.generateBrigadierCommand(args, executor) : null;
  for (int i = 0; i < requiredArguments.size(); i++) {
  Argument argument = requiredArguments.get(i);
  previousNodes = argument.addArgumentNodes(previousNodes, previousArguments, previousArgumentNames,
  // Only the last required argument is executable
- i == requiredArguments.size() - 1 ? executor : null);
+ i == requiredArguments.size() - 1 ? executorCreator : null);
  }
 
  // Add optional arguments
  for (Argument argument : optionalArguments) {
  // All optional arguments are executable
- previousNodes = argument.addArgumentNodes(previousNodes, previousArguments, previousArgumentNames, executor);
- }
-
- // Check greedy argument constraint
- // We need to check it down here so that all the combined arguments are properly considered after unpacking
- for (int i = 0; i < previousArguments.size() - 1 /* Minus one since we don't need to check last argument */; i++) {
- Argument argument = previousArguments.get(i);
- if (argument instanceof GreedyArgument) {
- throw new GreedyArgumentException(
- previousArguments.subList(0, i), // Arguments before this
- argument,
- List.of(previousArguments.subList(i + 1, previousArguments.size())) // Arguments after this
- );
- }
+ previousNodes = argument.addArgumentNodes(previousNodes, previousArguments, previousArgumentNames, executorCreator);
  }
  }
 

commandapi-core/src/main/java/dev/jorel/commandapi/AbstractCommandTree.java

@@ -120,10 +120,10 @@ protected <Source> void createArgumentNodes(LiteralCommandNode<Source> rootNode)
  for (AbstractArgumentTree<?, Argument, CommandSender> argument : arguments) {
  // We need new previousArguments lists for each branch so they don't interfere
  List<Argument> previousArguments = new ArrayList<>();
- List<String> previousNonLiteralArgumentNames = new ArrayList<>();
+ List<String> previousArgumentNames = new ArrayList<>();
  previousArguments.add(commandNames);
 
- argument.buildBrigadierNode(List.of(rootNode), previousArguments, previousNonLiteralArgumentNames);
+ argument.buildBrigadierNode(List.of(rootNode), previousArguments, previousArgumentNames);
  }
  }
 }

commandapi-core/src/main/java/dev/jorel/commandapi/CommandAPIHandler.java

@@ -40,6 +40,7 @@
 import com.mojang.brigadier.suggestion.SuggestionProvider;
 import com.mojang.brigadier.tree.CommandNode;
 import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.tree.ArgumentCommandNode;
 import com.mojang.brigadier.tree.LiteralCommandNode;
 import dev.jorel.commandapi.arguments.*;
 import dev.jorel.commandapi.commandsenders.AbstractCommandSender;
@@ -59,24 +60,35 @@
  * @param <Source> The class for running Brigadier commands
  */
 @RequireField(in = CommandContext.class, name = "arguments", ofType = Map.class)
+@RequireField(in = CommandNode.class, name = "children", ofType = Map.class)
+@RequireField(in = CommandNode.class, name = "literals", ofType = Map.class)
+@RequireField(in = CommandNode.class, name = "arguments", ofType = Map.class)
 public class CommandAPIHandler<Argument
 /// @cond DOX
 extends AbstractArgument<?, ?, Argument, CommandSender>
 /// @endcond
 , CommandSender, Source> {
+ // TODO: Need to ensure this can be safely "disposed of" when we're done (e.g. on reloads).
+ // I hiiiiiiighly doubt we're storing class caches of classes that can be unloaded at runtime,
+ // but this IS a generic class caching system and we don't want derpy memory leaks
+ private static final Map<ClassCache, Field> FIELDS;
+
  private static final SafeVarHandle<CommandContext<?>, Map<String, ParsedArgument<?, ?>>> commandContextArguments;
+ // VarHandle seems incapable of setting final fields, so we have to use Field here
+ private static final Field commandNodeChildren;
+ private static final Field commandNodeLiterals;
+ private static final Field commandNodeArguments;
 
- // Compute all var handles all in one go so we don't do this during main server
- // runtime
+ // Compute all var handles all in one go so we don't do this during main server runtime
  static {
+ FIELDS = new HashMap<>();
+
  commandContextArguments = SafeVarHandle.ofOrNull(CommandContext.class, "arguments", "arguments", Map.class);
+ commandNodeChildren = CommandAPIHandler.getField(CommandNode.class, "children");
+ commandNodeLiterals = CommandAPIHandler.getField(CommandNode.class, "literals");
+ commandNodeArguments = CommandAPIHandler.getField(CommandNode.class, "arguments");
  }
 
- // TODO: Need to ensure this can be safely "disposed of" when we're done (e.g. on reloads).
- // I hiiiiiiighly doubt we're storing class caches of classes that can be unloaded at runtime,
- // but this IS a generic class caching system and we don't want derpy memory leaks
- private static final Map<ClassCache, Field> FIELDS = new HashMap<>();
-
  final CommandAPIPlatform<Argument, CommandSender, Source> platform;
  final List<RegisteredCommand> registeredCommands; // Keep track of what has been registered for type checking
  final Map<List<String>, Previewable<?, ?>> previewableArguments; // Arguments with previewable chat
@@ -141,7 +153,7 @@ public CommandAPIPlatform<Argument, CommandSender, Source> getPlatform() {
  // SECTION: Creating commands //
  ////////////////////////////////
 
- void registerCommand(ExecutableCommand<?, CommandSender> command, String namespace) {
+ public void registerCommand(ExecutableCommand<?, CommandSender> command, String namespace) {
  platform.preCommandRegistration(command.getName());
 
  List<RegisteredCommand> registeredCommandInformation = RegisteredCommand.fromExecutableCommand(command, namespace);
@@ -431,6 +443,10 @@ public Predicate<Source> generateBrigadierRequirements(CommandPermission permiss
  };
  }
 
+ ////////////////////////////////
+ // SECTION: Brigadier Helpers //
+ ////////////////////////////////
+
  public void writeDispatcherToFile() {
  File file = CommandAPI.getConfiguration().getDispatcherFile();
  if (file != null) {
@@ -452,7 +468,7 @@ public void writeDispatcherToFile() {
  }
  }
 
- LiteralCommandNode<Source> namespaceNode(LiteralCommandNode<Source> original, String namespace) {
+ public LiteralCommandNode<Source> namespaceNode(LiteralCommandNode<Source> original, String namespace) {
  // Adapted from a section of `CraftServer#syncCommands`
  LiteralCommandNode<Source> clone = new LiteralCommandNode<>(
  namespace + ":" + original.getLiteral(),
@@ -469,6 +485,54 @@ LiteralCommandNode<Source> namespaceNode(LiteralCommandNode<Source> original, St
  return clone;
  }
 
+ public static <Source> Map<String, CommandNode<Source>> getCommandNodeChildren(CommandNode<Source> target) {
+ try {
+ return (Map<String, CommandNode<Source>>) commandNodeChildren.get(target);
+ } catch (IllegalAccessException e) {
+ throw new IllegalStateException("This shouldn't happen. The field should be accessible.", e);
+ }
+ }
+
+ public static <Source> void setCommandNodeChildren(CommandNode<Source> target, Map<String, CommandNode<Source>> children) {
+ try {
+ commandNodeChildren.set(target, children);
+ } catch (IllegalAccessException e) {
+ throw new IllegalStateException("This shouldn't happen. The field should be accessible.", e);
+ }
+ }
+
+ public static <Source> Map<String, LiteralCommandNode<Source>> getCommandNodeLiterals(CommandNode<Source> target) {
+ try {
+ return (Map<String, LiteralCommandNode<Source>>) commandNodeLiterals.get(target);
+ } catch (IllegalAccessException e) {
+ throw new IllegalStateException("This shouldn't happen. The field should be accessible.", e);
+ }
+ }
+
+ public static <Source> void setCommandNodeLiterals(CommandNode<Source> target, Map<String, LiteralCommandNode<Source>> literals) {
+ try {
+ commandNodeLiterals.set(target, literals);
+ } catch (IllegalAccessException e) {
+ throw new IllegalStateException("This shouldn't happen. The field should be accessible.", e);
+ }
+ }
+
+ public static <Source> Map<String, ArgumentCommandNode<Source, ?>> getCommandNodeArguments(CommandNode<Source> target) {
+ try {
+ return (Map<String, ArgumentCommandNode<Source, ?>>) commandNodeArguments.get(target);
+ } catch (IllegalAccessException e) {
+ throw new IllegalStateException("This shouldn't happen. The field should be accessible.", e);
+ }
+ }
+
+ public static <Source> void setCommandNodeArguments(CommandNode<Source> target, Map<String, ArgumentCommandNode<Source, ?>> arguments) {
+ try {
+ commandNodeArguments.set(target, arguments);
+ } catch (IllegalAccessException e) {
+ throw new IllegalStateException("This shouldn't happen. The field should be accessible.", e);
+ }
+ }
+
  ////////////////////////////////
  // SECTION: Parsing arguments //
  ////////////////////////////////
@@ -522,7 +586,7 @@ public static <CommandSource> String getRawArgumentInput(CommandContext<CommandS
  * @return an CommandArguments object which can be used in (sender, args) ->
  * @throws CommandSyntaxException If an argument is improperly formatted and cannot be parsed
  */
- CommandArguments argsToCommandArgs(CommandContext<Source> cmdCtx, List<Argument> args) throws CommandSyntaxException {
+ public CommandArguments argsToCommandArgs(CommandContext<Source> cmdCtx, List<Argument> args) throws CommandSyntaxException {
  // Array for arguments for executor
  List<Object> argList = new ArrayList<>();
 
@@ -564,7 +628,7 @@ CommandArguments argsToCommandArgs(CommandContext<Source> cmdCtx, List<Argument>
  * @return the Argument's corresponding object
  * @throws CommandSyntaxException when the input for the argument isn't formatted correctly
  */
- Object parseArgument(CommandContext<Source> cmdCtx, String key, Argument value, CommandArguments previousArgs) throws CommandSyntaxException {
+ public Object parseArgument(CommandContext<Source> cmdCtx, String key, Argument value, CommandArguments previousArgs) throws CommandSyntaxException {
  if (value.isListed()) {
  return value.parseArgument(cmdCtx, key, previousArgs);
  } else {