@SuppressWarnings({"unchecked"})
    private @NonNull Collection<org.incendo.cloud.@NonNull Command<C>> constructCommands(
            final @NonNull Object instance,
            final @NonNull CommandDescriptor commandDescriptor
    ) {
        final AnnotationAccessor classAnnotations = AnnotationAccessor.of(instance.getClass());
        final List<org.incendo.cloud.Command<C>> commands = new ArrayList<>();

        final Method method = commandDescriptor.method();
        final CommandManager<C> manager = this.manager;
        final CommandMetaBuilder metaBuilder = CommandMeta.builder().with(this.metaFactory.apply(method));

        org.incendo.cloud.Command.Builder<C> builder = manager.commandBuilder(
                commandDescriptor.commandToken(),
                commandDescriptor.syntax().get(0).minor(),
                metaBuilder.build()
        );
        for (final BuilderDecorator<C> decorator : this.builderDecorators) {
            builder = decorator.decorate(builder);
        }

        final Collection<ArgumentDescriptor> arguments = this.argumentExtractor.extractArguments(
                commandDescriptor.syntax(),
                method
        );
        final Collection<FlagDescriptor> flagDescriptors = this.flagExtractor.extractFlags(method);
        final Collection<CommandFlag<?>> flags = flagDescriptors.stream()
                .map(this.flagAssembler()::assembleFlag)
                .collect(Collectors.toList());
        final Map<String, CommandComponent<C>> commandComponents = this.constructComponents(arguments, commandDescriptor);

        boolean commandNameFound = false;
        /* Build the command tree */
        for (final SyntaxFragment token : commandDescriptor.syntax()) {
            if (!commandNameFound) {
                commandNameFound = true;
                continue;
            }
            if (token.argumentMode() == ArgumentMode.LITERAL) {
                builder = builder.literal(token.major(), token.minor().toArray(new String[0]));
            } else {
                final CommandComponent<C> component = commandComponents.get(token.major());
                if (component == null) {
                    throw new IllegalArgumentException(String.format(
                            "Found no mapping for argument '%s' in method '%s'",
                            token.major(), method.getName()
                    ));
                }

                builder = builder.argument(component);
            }
        }
        /* Try to find the command sender type */
        Class<? extends C> senderType = null;
        for (final Parameter parameter : method.getParameters()) {
            if (parameter.isAnnotationPresent(Argument.class)) {
                continue;
            }
            if (GenericTypeReflector.isSuperType(this.commandSenderType.getType(), parameter.getType())) {
                senderType = (Class<? extends C>) parameter.getType();
                break;
            }
        }

        final Permission permission = getMethodOrClassAnnotation(method, Permission.class);
        if (permission != null) {
            final String[] permissions = permission.value();
            if (permissions.length == 1) {
                builder = builder.permission(this.processString(permissions[0]));
            } else if (permissions.length > 1) {
                builder = builder.permission(
                        permission.mode().combine(
                                Arrays.stream(permissions)
                                        .map(this::processString)
                                        .map(org.incendo.cloud.permission.Permission::permission)
                        )
                );
            }
        }

        if (commandDescriptor.requiredSender() != Object.class) {
            builder = builder.senderType((Class<? extends C>) commandDescriptor.requiredSender());
        } else if (senderType != null) {
            builder = builder.senderType(senderType);
        }
        try {
            final MethodCommandExecutionHandler.CommandMethodContext<C> context =
                    new MethodCommandExecutionHandler.CommandMethodContext<>(
                            instance,
                            commandComponents,
                            arguments,
                            flagDescriptors,
                            method,
                            this /* annotationParser */
                    );

            /* Create the command execution handler */
            CommandExecutionHandler<C> commandExecutionHandler = new MethodCommandExecutionHandler<>(context);
            for (final Map.Entry<Predicate<Method>, CommandMethodExecutionHandlerFactory<C>> entry
                    : this.commandMethodFactories.entrySet()) {
                if (entry.getKey().test(method)) {
                    commandExecutionHandler = entry.getValue().createExecutionHandler(context);

                    /* Once we have our custom handler, we stop */
                    break;
                }
            }

            builder = builder.handler(commandExecutionHandler);
        } catch (final Exception e) {
            throw new RuntimeException("Failed to construct command execution handler", e);
        }
        /* Apply flags */
        for (final CommandFlag<?> flag : flags) {
            builder = builder.flag(flag);
        }

        /* Apply builder modifiers */
        for (final Annotation annotation
                : AnnotationAccessor.of(classAnnotations, AnnotationAccessor.of(method)).annotations()) {
            @SuppressWarnings("rawtypes") final BuilderModifier builderModifier = this.builderModifiers.get(
                    annotation.annotationType()
            );
            if (builderModifier == null) {
                continue;
            }
            builder = (org.incendo.cloud.Command.Builder<C>) builderModifier.modifyBuilder(annotation, builder);
        }

        /* Construct and register the command */
        final org.incendo.cloud.Command<C> builtCommand = builder.build();
        commands.add(builtCommand);

        if (method.isAnnotationPresent(ProxiedBy.class)) {
            manager.command(this.constructProxy(method.getAnnotation(ProxiedBy.class), builtCommand));
        }

        return commands;
    }
Maps the given {@code string} into a {@link Description}.

@param string description literal
@return the description
cloud-annotations/src/main/java/org/incendo/cloud/annotations/AnnotationParser.java