Removed TypeSuggestionResolver.java

bukkit/src/main/java/dev/velix/imperat/BukkitImperat.java

@@ -230,7 +230,8 @@ private void registerValueResolvers() {
         this.registerParamType(Player.class, new ParameterPlayer());
         this.registerParamType(OfflinePlayer.class, new ParameterOfflinePlayer());
         this.registerParamType(TargetSelector.class, new ParameterTargetSelector());
-        this.registerParamType(Reflections.getClass("org.bukkit.World"), new ParameterWorld());
+        var worldClass = Reflections.getClass("org.bukkit.World");
+        this.registerParamType(worldClass, new ParameterWorld(worldClass));
     }
 
     public void applyBrigadier() {

bukkit/src/main/java/dev/velix/imperat/type/ParameterOfflinePlayer.java

@@ -6,10 +6,12 @@
 import dev.velix.imperat.command.parameters.CommandParameter;
 import dev.velix.imperat.command.parameters.type.BaseParameterType;
 import dev.velix.imperat.context.ExecutionContext;
+import dev.velix.imperat.context.SuggestionContext;
 import dev.velix.imperat.context.internal.CommandInputStream;
 import dev.velix.imperat.exception.ImperatException;
 import dev.velix.imperat.exception.UnknownOfflinePlayerException;
 import dev.velix.imperat.exception.UnknownPlayerException;
+import dev.velix.imperat.resolvers.SuggestionResolver;
 import dev.velix.imperat.util.TypeWrap;
 import net.minecraft.server.v1_13_R2.MinecraftServer;
 import org.bukkit.Bukkit;
@@ -19,6 +21,8 @@
 import org.jetbrains.annotations.Nullable;
 import org.spigotmc.SpigotConfig;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.UUID;
 
 public class ParameterOfflinePlayer extends BaseParameterType<BukkitSource, OfflinePlayer> {
@@ -69,5 +73,18 @@ public boolean matchesInput(String input, CommandParameter<BukkitSource> paramet
         return input.length() <= 16;
     }
 
+    private final static class PlayerSuggestionResolver implements SuggestionResolver<BukkitSource> {
 
+        /**
+         * @param context   the context for suggestions
+         * @param parameter the parameter of the value to complete
+         * @return the auto-completed suggestions of the current argument
+         */
+        @Override
+        public Collection<String> autoComplete(SuggestionContext<BukkitSource> context, CommandParameter<BukkitSource> parameter) {
+            return Arrays.stream(Bukkit.getOfflinePlayers())
+                .map(OfflinePlayer::getName)
+                .toList();
+        }
+    }
 }

bukkit/src/main/java/dev/velix/imperat/type/ParameterPlayer.java

@@ -4,17 +4,22 @@
 import dev.velix.imperat.command.parameters.CommandParameter;
 import dev.velix.imperat.command.parameters.type.BaseParameterType;
 import dev.velix.imperat.context.ExecutionContext;
+import dev.velix.imperat.context.SuggestionContext;
 import dev.velix.imperat.context.internal.CommandInputStream;
 import dev.velix.imperat.exception.ImperatException;
 import dev.velix.imperat.exception.UnknownPlayerException;
+import dev.velix.imperat.resolvers.SuggestionResolver;
 import dev.velix.imperat.util.TypeWrap;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Collection;
+
 public class ParameterPlayer extends BaseParameterType<BukkitSource, Player> {
 
+    private final PlayerSuggestionResolver SUGGESTION_RESOLVER = new PlayerSuggestionResolver();
     public ParameterPlayer() {
         super(TypeWrap.of(Player.class));
     }
@@ -43,4 +48,26 @@ public boolean matchesInput(String input, CommandParameter<BukkitSource> paramet
         return input.length() <= 16;
     }
 
+    /**
+     * Returns the suggestion resolver associated with this parameter type.
+     *
+     * @return the suggestion resolver for generating suggestions based on the parameter type.
+     */
+    @Override
+    public SuggestionResolver<BukkitSource> getSuggestionResolver() {
+        return SUGGESTION_RESOLVER;
+    }
+
+    private final static class PlayerSuggestionResolver implements SuggestionResolver<BukkitSource> {
+
+        /**
+         * @param context   the context for suggestions
+         * @param parameter the parameter of the value to complete
+         * @return the auto-completed suggestions of the current argument
+         */
+        @Override
+        public Collection<String> autoComplete(SuggestionContext<BukkitSource> context, CommandParameter<BukkitSource> parameter) {
+            return Bukkit.getOnlinePlayers().stream().map(Player::getName).toList();
+        }
+    }
 }

bukkit/src/main/java/dev/velix/imperat/type/ParameterTargetSelector.java

@@ -8,7 +8,7 @@
 import dev.velix.imperat.context.internal.CommandInputStream;
 import dev.velix.imperat.exception.ImperatException;
 import dev.velix.imperat.exception.SourceException;
-import dev.velix.imperat.resolvers.TypeSuggestionResolver;
+import dev.velix.imperat.resolvers.SuggestionResolver;
 import dev.velix.imperat.selector.EntityCondition;
 import dev.velix.imperat.selector.SelectionParameterInput;
 import dev.velix.imperat.selector.SelectionType;
@@ -31,14 +31,14 @@ public final class ParameterTargetSelector extends BaseParameterType<BukkitSourc
     private final static char PARAMETER_START = '[';
     private final static char PARAMETER_END = ']';
 
-    private final TypeSuggestionResolver<BukkitSource, TargetSelector> suggestionResolver;
+    private final SuggestionResolver<BukkitSource> suggestionResolver;
 
     public ParameterTargetSelector() {
         super(TypeWrap.of(TargetSelector.class));
         SelectionType.TYPES.stream()
             .filter(type -> type != SelectionType.UNKNOWN)
             .map(SelectionType::id)
-            .forEach((id) -> suggestions.add(String.valueOf(SelectionType.MENTION_CHARACTER + id)));
+            .forEach((id) -> suggestions.add(SelectionType.MENTION_CHARACTER + id));
         suggestionResolver = new TargetSelectorSuggestionResolver();
     }
 
@@ -135,19 +135,11 @@ private static <V> void operateFields(List<SelectionParameterInput<?>> inputPara
      * @return the suggestion resolver for generating suggestions based on the parameter type.
      */
     @Override
-    public TypeSuggestionResolver<BukkitSource, TargetSelector> getSuggestionResolver() {
+    public SuggestionResolver<BukkitSource> getSuggestionResolver() {
         return suggestionResolver;
     }
 
-    private final class TargetSelectorSuggestionResolver implements TypeSuggestionResolver<BukkitSource, TargetSelector> {
-
-        /**
-         * @return the valueType that is specific for these suggestions resolving
-         */
-        @Override
-        public @NotNull TypeWrap<TargetSelector> getType() {
-            return TypeWrap.of(TargetSelector.class);
-        }
+    private final class TargetSelectorSuggestionResolver implements SuggestionResolver<BukkitSource> {
 
         /**
          * @param context   the context for suggestions

bukkit/src/main/java/dev/velix/imperat/type/ParameterWorld.java

@@ -7,14 +7,18 @@
 import dev.velix.imperat.context.internal.CommandInputStream;
 import dev.velix.imperat.exception.ImperatException;
 import dev.velix.imperat.exception.UnknownWorldException;
+import dev.velix.imperat.resolvers.SuggestionResolver;
 import dev.velix.imperat.util.TypeWrap;
 import dev.velix.imperat.util.reflection.Reflections;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Objects;
 
 public class ParameterWorld extends BaseParameterType<BukkitSource, World> {
 
@@ -26,14 +30,17 @@ public class ParameterWorld extends BaseParameterType<BukkitSource, World> {
         try {
             assert WORLD_CLASS != null;
             GET_WORLDS = Bukkit.class.getMethod("getWorlds");
+            GET_WORLDS.setAccessible(true);
+
             GET_NAME = WORLD_CLASS.getMethod("getName");
+            GET_NAME.setAccessible(true);
         } catch (NoSuchMethodException e) {
             throw new RuntimeException(e);
         }
     }
 
-    public ParameterWorld() {
-        super(TypeWrap.of(World.class));
+    public ParameterWorld(Class<?> type) {
+        super(TypeWrap.of((Class<World>) type));
     }
 
     @Override
@@ -51,4 +58,30 @@ public boolean matchesInput(String input, CommandParameter<BukkitSource> paramet
         return super.matchesInput(input, parameter);
     }
 
+    /**
+     * Returns the suggestion resolver associated with this parameter type.
+     *
+     * @return the suggestion resolver for generating suggestions based on the parameter type.
+     */
+    @Override
+    @SuppressWarnings("unchecked")
+    public SuggestionResolver<BukkitSource> getSuggestionResolver() {
+        try {
+            return SuggestionResolver.plain(((List<Object>) GET_WORLDS.invoke(null))
+                .stream()
+                .map((obj) -> {
+                    try {
+                        return (String) GET_NAME.invoke(obj);
+                    } catch (IllegalAccessException | InvocationTargetException e) {
+                        return null;
+                    }
+                })
+                .filter(Objects::nonNull)
+                .toList()
+            );
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+
+    }
 }

bungee/src/main/java/dev/velix/imperat/type/ParameterProxiedPlayer.java

@@ -4,17 +4,22 @@
 import dev.velix.imperat.command.parameters.CommandParameter;
 import dev.velix.imperat.command.parameters.type.BaseParameterType;
 import dev.velix.imperat.context.ExecutionContext;
+import dev.velix.imperat.context.SuggestionContext;
 import dev.velix.imperat.context.internal.CommandInputStream;
 import dev.velix.imperat.exception.ImperatException;
 import dev.velix.imperat.exception.UnknownPlayerException;
+import dev.velix.imperat.resolvers.SuggestionResolver;
 import dev.velix.imperat.util.TypeWrap;
 import net.md_5.bungee.api.ProxyServer;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Collection;
+
 public final class ParameterProxiedPlayer extends BaseParameterType<BungeeSource, ProxiedPlayer> {
 
+    private final ProxiedPlayerSuggestionResolver PROXIED_PLAYER_SUGGESTION_RESOLVER = new ProxiedPlayerSuggestionResolver();
     public ParameterProxiedPlayer() {
         super(TypeWrap.of(ProxiedPlayer.class));
     }
@@ -46,4 +51,29 @@ public boolean matchesInput(String input, CommandParameter<BungeeSource> paramet
         return ProxyServer.getInstance().getPlayer(input) != null;
     }
 
+    /**
+     * Returns the suggestion resolver associated with this parameter type.
+     *
+     * @return the suggestion resolver for generating suggestions based on the parameter type.
+     */
+    @Override
+    public SuggestionResolver<BungeeSource> getSuggestionResolver() {
+        return PROXIED_PLAYER_SUGGESTION_RESOLVER;
+    }
+
+    private final static class ProxiedPlayerSuggestionResolver implements SuggestionResolver<BungeeSource> {
+
+        /**
+         * @param context   the context for suggestions
+         * @param parameter the parameter of the value to complete
+         * @return the auto-completed suggestions of the current argument
+         */
+        @Override
+        public Collection<String> autoComplete(SuggestionContext<BungeeSource> context, CommandParameter<BungeeSource> parameter) {
+            return ProxyServer.getInstance().getPlayers().stream()
+                .map(ProxiedPlayer::getName)
+                .toList();
+        }
+    }
+
 }

core/src/main/java/dev/velix/imperat/ResolverRegistrar.java

@@ -125,7 +125,7 @@ default <T> ContextResolver<S, T> getContextResolver(CommandParameter<S> command
         if (parameterSpecificResolver == null) {
             var resolverByType = getSuggestionResolverByType(parameter.valueType());
             if (resolverByType != null) return resolverByType;
-            else return SuggestionResolver.type(String.class, Collections.singletonList(parameter.format()));
+            else return SuggestionResolver.plain(Collections.singletonList(parameter.format()));
         } else
             return parameterSpecificResolver;
     }

core/src/main/java/dev/velix/imperat/annotations/base/element/SimpleCommandClassVisitor.java

@@ -20,7 +20,6 @@
 import dev.velix.imperat.command.processors.CommandPreProcessor;
 import dev.velix.imperat.context.Source;
 import dev.velix.imperat.resolvers.SuggestionResolver;
-import dev.velix.imperat.resolvers.TypeSuggestionResolver;
 import dev.velix.imperat.supplier.OptionalValueSupplier;
 import dev.velix.imperat.util.TypeUtility;
 import dev.velix.imperat.util.TypeWrap;
@@ -441,22 +440,19 @@ private <T> CommandParameter<S> loadParameter(
         Suggest suggestAnnotation = element.getAnnotation(Suggest.class);
         SuggestionProvider suggestionProvider = element.getAnnotation(SuggestionProvider.class);
 
-        TypeSuggestionResolver<S, ?> suggestionResolver = null;
+        SuggestionResolver<S> suggestionResolver = null;
 
         if (suggestAnnotation != null) {
-            suggestionResolver = SuggestionResolver.type(
-                parameterTypeWrap,
+            suggestionResolver = SuggestionResolver.plain(
                 imperat.replacePlaceholders(suggestAnnotation.value())
             );
         } else if (suggestionProvider != null) {
             String suggestionResolverName = imperat.replacePlaceholders(suggestionProvider.value().toLowerCase());
             var namedResolver = imperat.getNamedSuggestionResolver(
                 suggestionResolverName
             );
-            if (namedResolver != null && !(namedResolver instanceof TypeSuggestionResolver<?, ?>))
-                throw new UnsupportedOperationException("Named suggestion resolvers must be of valueType `TypeSuggestionResolver` and make sure the valueType matches that of the parameter's");
-            else if (namedResolver != null)
-                suggestionResolver = (TypeSuggestionResolver<S, ?>) namedResolver;
+            if (namedResolver != null)
+                suggestionResolver = namedResolver;
             else {
                 throw new IllegalStateException("Unregistered named suggestion resolver : " + suggestionResolverName);
             }
@@ -494,12 +490,12 @@ else if (namedResolver != null)
         if (flag != null) {
             String[] flagAliases = flag.value();
             if (suggestAnnotation != null) {
-                suggestionResolver = SuggestionResolver.type(TypeWrap.of(parameter.getParameterizedType()), imperat.replacePlaceholders(suggestAnnotation.value()));
+                suggestionResolver = SuggestionResolver.plain(imperat.replacePlaceholders(suggestAnnotation.value()));
             }
 
             return AnnotationParameterDecorator.decorate(
                 CommandParameter.flag(name, type)
-                    .suggestForInputValue((TypeSuggestionResolver<S, T>) suggestionResolver)
+                    .suggestForInputValue(suggestionResolver)
                     .aliases(getAllExceptFirst(flagAliases))
                     .flagDefaultInputValue(optionalValueSupplier)
                     .description(desc)

core/src/main/java/dev/velix/imperat/command/CommandImpl.java

@@ -15,7 +15,6 @@
 import dev.velix.imperat.exception.ImperatException;
 import dev.velix.imperat.help.PaginatedHelpTemplate;
 import dev.velix.imperat.resolvers.SuggestionResolver;
-import dev.velix.imperat.resolvers.TypeSuggestionResolver;
 import dev.velix.imperat.util.ImperatDebugger;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
@@ -210,8 +209,8 @@ public FlagParameter<S> asFlagParameter() {
      * @return the {@link SuggestionResolver} for a resolving suggestion
      */
     @Override
-    public @Nullable <T> TypeSuggestionResolver<S, T> getSuggestionResolver() {
-        return (TypeSuggestionResolver<S, T>) suggestionResolver;
+    public @Nullable SuggestionResolver<S> getSuggestionResolver() {
+        return suggestionResolver;
     }
 
     @Override

core/src/main/java/dev/velix/imperat/command/parameters/CommandParameter.java

@@ -9,7 +9,6 @@
 import dev.velix.imperat.command.parameters.type.ParameterTypes;
 import dev.velix.imperat.context.Source;
 import dev.velix.imperat.resolvers.SuggestionResolver;
-import dev.velix.imperat.resolvers.TypeSuggestionResolver;
 import dev.velix.imperat.supplier.OptionalValueSupplier;
 import dev.velix.imperat.util.Preconditions;
 import dev.velix.imperat.util.TypeWrap;
@@ -34,7 +33,7 @@ static <S extends Source, T> CommandParameter<S> of(
         boolean optional,
         boolean greedy,
         @NotNull OptionalValueSupplier<T> valueSupplier,
-        @Nullable TypeSuggestionResolver<S, ?> suggestionResolver
+        @Nullable SuggestionResolver<S> suggestionResolver
     ) {
         Preconditions.notNull(name, "name");
         Preconditions.notNull(type, "type");
@@ -236,11 +235,10 @@ default AnnotatedParameter<S> asAnnotated() {
      * Fetches the suggestion resolver linked to this
      * command parameter.
      *
-     * @param <T> the valueType of value to be resolved
      * @return the {@link SuggestionResolver} for a resolving suggestion
      */
     @Nullable
-    <T> TypeSuggestionResolver<S, T> getSuggestionResolver();
+    SuggestionResolver<S> getSuggestionResolver();
 
     /**
      * Formats the usage parameter*