@Override
    public final @NonNull Collection<@NonNull ArgumentDescriptor> extractArguments(
            final @NonNull List<@NonNull SyntaxFragment> syntax,
            final @NonNull Method method
    ) {
        final Map<String, SyntaxFragment> variableFragments = new HashMap<>();
        syntax.stream()
                .filter(fragment -> fragment.argumentMode() != ArgumentMode.LITERAL)
                .forEach(fragment -> variableFragments.put(fragment.major(), fragment));

        final Collection<ArgumentDescriptor> arguments = new ArrayList<>();
        for (final Parameter parameter : method.getParameters()) {
            final String parameterName = this.parameterNameExtractor().extract(parameter);

            DefaultValue<?, ?> defaultValue = null;
            if (parameter.isAnnotationPresent(Default.class)) {
                final Default defaultAnnotation = parameter.getAnnotation(Default.class);
                if (defaultAnnotation.name().isEmpty()) {
                    defaultValue = DefaultValue.parsed(this.annotationParser()
                            .processString(parameter.getAnnotation(Default.class).value()));
                } else {
                    final DefaultValueFactory<?, ?> factory = this.annotationParser()
                            .defaultValueRegistry()
                            .named(this.annotationParser().processString(defaultAnnotation.name()))
                            .orElseThrow(() -> new IllegalArgumentException(String.format(
                                    "No default value factory named '%s' has been registered",
                                    defaultAnnotation.name()))
                            );
                    defaultValue = factory.create(parameter);
                }
            }

            if (!parameter.isAnnotationPresent(Argument.class)) {
                final SyntaxFragment fragment = variableFragments.get(parameterName);
                if (fragment != null) {
                    arguments.add(
                            ArgumentDescriptor.builder()
                                    .parameter(parameter)
                                    .defaultValue(defaultValue)
                                    .name(parameterName)
                                    .build()
                    );
                }
                continue;
            }

            final Argument argument = parameter.getAnnotation(Argument.class);

            final String name;
            if (argument.value().equals(AnnotationParser.INFERRED_ARGUMENT_NAME)) {
                name = parameterName;
            } else {
                name = this.annotationParser().processString(argument.value());
            }

            final ArgumentDescriptor argumentDescriptor = ArgumentDescriptor.builder()
                    .parameter(parameter)
                    .name(name)
                    .parserName(nullIfEmpty(this.annotationParser().processString(argument.parserName())))
                    .defaultValue(defaultValue)
                    .description(this.descriptionMapper().map(argument.description()))
                    .suggestions(nullIfEmpty(this.annotationParser().processString(argument.suggestions())))
                    .build();
            arguments.add(argumentDescriptor);
        }
        return arguments;
    }
Returns the description mapper.

@return the description mapper
cloud-annotations/src/main/java/org/incendo/cloud/annotations/extractor/StandardArgumentExtractor.java