Function Overloading (#7757)

Author: Efnilite

.github/CODEOWNERS

@@ -63,3 +63,6 @@
 
 # Documentation
 /src/main/java/ch/njol/skript/doc/ @Pikachu920 @AyhamAl-Ali @Efnilite @skriptlang/core-developers
+
+# Functions
+/src/main/java/ch/njol/skript/lang/function @Efnilite @skriptlang/core-developers

src/main/java/ch/njol/skript/Skript.java

@@ -1775,6 +1775,8 @@ public static void debug(final String info) {
 	 * @see String#formatted(Object...)
 	 */
 	public static void debug(String message, Object... objects) {
+		if (!debug())
+			return;
 		debug(message.formatted(objects));
 	}
 
@@ -1803,6 +1805,17 @@ public static void error(final @Nullable String error) {
 			SkriptLogger.log(Level.SEVERE, error);
 	}
 
+	/**
+	 * Sends an error message with formatted objects.
+	 *
+	 * @param message The message to send
+	 * @param objects The objects to format the message with
+	 * @see String#formatted(Object...)
+	 */
+	public static void error(String message, Object... objects) {
+		error(message.formatted(objects));
+	}
+
 	/**
 	 * Use this in {@link Expression#init(Expression[], int, Kleenean, ch.njol.skript.lang.SkriptParser.ParseResult)} (and other methods that are called during the parsing) to log
 	 * errors with a specific {@link ErrorQuality}.

src/main/java/ch/njol/skript/lang/function/DynamicFunctionReference.java

@@ -1,6 +1,7 @@
 package ch.njol.skript.lang.function;
 
 import ch.njol.skript.ScriptLoader;
+import ch.njol.skript.Skript;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.ExpressionList;
 import ch.njol.skript.lang.util.common.AnyNamed;
@@ -56,12 +57,15 @@ public DynamicFunctionReference(@NotNull String name, @Nullable Script source) {
 		this.name = name;
 		Function<? extends Result> function;
 		if (source != null) {
+			// will return the first function found that matches name.
+			// TODO: add a way to specify param types
 			//noinspection unchecked
-			function = (Function<? extends Result>) Functions.getFunction(name, source.getConfig().getFileName());
+			function = (Function<? extends Result>) FunctionRegistry.getRegistry().getFunction(source.getConfig().getFileName(), name).retrieved();
 		} else {
 			//noinspection unchecked
-			function = (Function<? extends Result>) Functions.getFunction(name, null);
+			function = (Function<? extends Result>) FunctionRegistry.getRegistry().getFunction(null, name).retrieved();
 		}
+
 		this.resolved = function != null;
 		this.function = new WeakReference<>(function);
 		if (resolved) {

src/main/java/ch/njol/skript/lang/function/FunctionReference.java

@@ -1,6 +1,5 @@
 package ch.njol.skript.lang.function;
 
-
 import ch.njol.skript.Skript;
 import ch.njol.skript.SkriptAPIException;
 import ch.njol.skript.classes.ClassInfo;
@@ -9,24 +8,31 @@
 import ch.njol.skript.lang.KeyProviderExpression;
 import ch.njol.skript.lang.KeyedValue;
 import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.lang.function.FunctionRegistry.Retrieval;
+import ch.njol.skript.lang.function.FunctionRegistry.RetrievalResult;
 import ch.njol.skript.log.RetainingLogHandler;
 import ch.njol.skript.log.SkriptLogger;
 import ch.njol.skript.registrations.Classes;
 import ch.njol.skript.util.Contract;
 import ch.njol.skript.util.LiteralUtils;
 import ch.njol.util.StringUtils;
 import org.bukkit.event.Event;
-import org.skriptlang.skript.util.Executable;
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.lang.converter.Converters;
-
+import org.skriptlang.skript.util.Executable;
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * Reference to a {@link Function Skript function}.
  */
 public class FunctionReference<T> implements Contract, Executable<Event, T[]> {
 
+	private static final String AMBIGUOUS_ERROR =
+		"Skript cannot determine which function named '%s' to call. " +
+		"The following functions were matched: %s. " +
+		"Try clarifying the type of the arguments using the 'value within' expression.";
+
 	/**
 	 * Name of function that is called, for logging purposes.
 	 */
@@ -85,8 +91,8 @@ public class FunctionReference<T> implements Contract, Executable<Event, T[]> {
 	private Contract contract;
 
 	public FunctionReference(
-			String functionName, @Nullable Node node, @Nullable String script,
-			@Nullable Class<? extends T>[] returnTypes, Expression<?>[] params
+		String functionName, @Nullable Node node, @Nullable String script,
+		@Nullable Class<? extends T>[] returnTypes, Expression<?>[] params
 	) {
 		this.functionName = functionName;
 		this.node = node;
@@ -99,17 +105,23 @@ public FunctionReference(
 	public boolean validateParameterArity(boolean first) {
 		if (!first && script == null)
 			return false;
-		Signature<?> sign = Functions.getSignature(functionName, script);
+
+		Signature<?> sign = getRegisteredSignature();
+
 		if (sign == null)
 			return false;
+
 		// Not enough parameters
 		return parameters.length >= sign.getMinParameters();
 	}
 
+	private Class<?>[] parameterTypes;
+
 	/**
 	 * Validates this function reference. Prints errors if needed.
+	 *
 	 * @param first True if this is called while loading a script. False when
-	 * this is called when the function signature changes.
+	 *              this is called when the function signature changes.
 	 * @return True if validation succeeded.
 	 */
 	public boolean validateFunction(boolean first) {
@@ -119,7 +131,7 @@ public boolean validateFunction(boolean first) {
 		function = null;
 		SkriptLogger.setNode(node);
 		Skript.debug("Validating function " + functionName);
-		Signature<?> sign = Functions.getSignature(functionName, script);
+		Signature<?> sign = getRegisteredSignature();
 
 		// Check if the requested function exists
 		if (sign == null) {
@@ -161,7 +173,7 @@ public boolean validateFunction(boolean first) {
 				single = sign.single;
 			} else if (single && !sign.single) {
 				Skript.error("The function '" + functionName + "' was redefined with a different, incompatible return type, but is still used in other script(s)."
-						+ " These will continue to use the old version of the function until Skript restarts.");
+					+ " These will continue to use the old version of the function until Skript restarts.");
 				function = previousFunction;
 				return false;
 			}
@@ -253,6 +265,80 @@ public boolean validateFunction(boolean first) {
 		return true;
 	}
 
+	// attempt to get the types of the parameters for this function reference
+	private void parseParameters() {
+		if (parameterTypes != null) {
+			return;
+		}
+
+		parameterTypes = new Class<?>[parameters.length];
+		for (int i = 0; i < parameters.length; i++) {
+			Expression<?> parsed = LiteralUtils.defendExpression(parameters[i]);
+			parameterTypes[i] = parsed.getReturnType();
+		}
+	}
+
+	/**
+	 * Attempts to get this function's signature.
+	 */
+	private Signature<?> getRegisteredSignature() {
+		parseParameters();
+
+		if (Skript.debug()) {
+			Skript.debug("Getting signature for '%s' with types %s",
+				functionName, Arrays.toString(Arrays.stream(parameterTypes).map(Class::getSimpleName).toArray()));
+		}
+
+		Retrieval<Signature<?>> attempt = FunctionRegistry.getRegistry().getSignature(script, functionName, parameterTypes);
+		if (attempt.result() == RetrievalResult.EXACT) {
+			return attempt.retrieved();
+		}
+
+		// if we can't find a signature based on param types, try to match any function
+		attempt = FunctionRegistry.getRegistry().getSignature(script, functionName);
+
+		if (attempt.result() == RetrievalResult.EXACT) {
+			return attempt.retrieved();
+		}
+
+		if (attempt.result() == RetrievalResult.AMBIGUOUS) {
+			ambiguousError(attempt.conflictingArgs());
+		}
+
+		return null;
+	}
+
+	/**
+	 * Attempts to get this function's registered implementation.
+	 */
+	private Function<?> getRegisteredFunction() {
+		parseParameters();
+
+		if (Skript.debug()) {
+			Skript.debug("Getting function '%s' with types %s",
+				functionName, Arrays.toString(Arrays.stream(parameterTypes).map(Class::getSimpleName).toArray()));
+		}
+
+		Retrieval<Function<?>> attempt = FunctionRegistry.getRegistry().getFunction(script, functionName, parameterTypes);
+
+		if (attempt.result() == RetrievalResult.EXACT) {
+			return attempt.retrieved();
+		}
+
+		// if we can't find a signature based on param types, try to match any function
+		attempt = FunctionRegistry.getRegistry().getFunction(script, functionName);
+
+		if (attempt.result() == RetrievalResult.EXACT) {
+			return attempt.retrieved();
+		}
+
+		if (attempt.result() == RetrievalResult.AMBIGUOUS) {
+			ambiguousError(attempt.conflictingArgs());
+		}
+
+		return null;
+	}
+
 	public @Nullable Function<? extends T> getFunction() {
 		return function;
 	}
@@ -273,7 +359,7 @@ public boolean resetReturnValue() {
 		// If needed, acquire the function reference
 		if (function == null)
 			//noinspection unchecked
-			function = (Function<? extends T>) Functions.getFunction(functionName, script);
+			function = (Function<? extends T>) getRegisteredFunction();
 
 		if (function == null) { // It might be impossible to resolve functions in some cases!
 			Skript.error("Couldn't resolve call for '" + functionName + "'.");
@@ -369,6 +455,7 @@ public boolean isSingle(Expression<?>... arguments) {
 
 	/**
 	 * The contract is used in preference to the function for determining return type, etc.
+	 *
 	 * @return The contract determining this function's parse-time hints, potentially this reference
 	 */
 	public Contract getContract() {
@@ -391,7 +478,7 @@ public T[] execute(Event event, Object... arguments) {
 		// If needed, acquire the function reference
 		if (function == null)
 			//noinspection unchecked
-			function = (Function<? extends T>) Functions.getFunction(functionName, script);
+			function = (Function<? extends T>) getRegisteredFunction();
 
 		if (function == null) { // It might be impossible to resolve functions in some cases!
 			Skript.error("Couldn't resolve call for '" + functionName + "'.");
@@ -419,4 +506,23 @@ static Object[][] consign(Object... arguments) {
 
 	}
 
+	private void ambiguousError(Class<?>[][] conflictingArgs) {
+		List<String> parts = new ArrayList<>();
+		for (Class<?>[] args : conflictingArgs) {
+			String argNames = Arrays.stream(args).map(arg -> {
+				String name = Classes.getExactClassName(arg);
+
+				if (name == null) {
+					return arg.getSimpleName();
+				} else {
+					return name.toLowerCase();
+				}
+			}).collect(Collectors.joining(", "));
+
+			parts.add("%s(%s)".formatted(functionName, argNames));
+		}
+
+		Skript.error(AMBIGUOUS_ERROR, functionName, StringUtils.join(parts, ", ", " and "));
+	}
+
 }