Fix Direction and ConvertedExpression simplification

Author: sovdeeth

src/main/java/ch/njol/skript/expressions/arithmetic/ExprArithmetic.java

@@ -23,6 +23,7 @@
 import org.skriptlang.skript.lang.arithmetic.Arithmetics;
 import org.skriptlang.skript.lang.arithmetic.OperationInfo;
 import org.skriptlang.skript.lang.arithmetic.Operator;
+import org.skriptlang.skript.lang.simplification.SimplifiedLiteral;
 
 import java.lang.reflect.Array;
 import java.util.ArrayList;
@@ -380,7 +381,7 @@ private Expression<T> simplifyInternal() {
 		}
 
 		if (first instanceof Literal && second instanceof Literal)
-			return getAsSimplifiedLiteral();
+			return SimplifiedLiteral.fromExpression(this);
 
 		return this;
 	}

src/main/java/ch/njol/skript/lang/Expression.java

@@ -5,7 +5,6 @@
 import ch.njol.skript.classes.Changer.ChangeMode;
 import ch.njol.skript.classes.Changer.ChangerUtils;
 import ch.njol.skript.conditions.CondIsSet;
-import ch.njol.skript.lang.util.ContextlessEvent;
 import ch.njol.skript.lang.util.ConvertedExpression;
 import ch.njol.skript.lang.util.SimpleExpression;
 import ch.njol.skript.log.ErrorQuality;
@@ -18,7 +17,6 @@
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.lang.converter.Converter;
 import org.skriptlang.skript.lang.simplification.Simplifiable;
-import org.skriptlang.skript.lang.simplification.SimplifiedLiteral;
 
 import java.util.*;
 import java.util.function.Function;
@@ -249,18 +247,6 @@ default boolean canReturn(Class<?> returnType) {
 	 */
 	Expression<?> getSource();
 
-	/**
-	 * Attempts to create a {@link SimplifiedLiteral} by evaluating the expression with a {@link ContextlessEvent}.
-	 * This should only be attempted IFF the expression's children are all literals and
-	 * {@link #getAll(Event)} would always return the exact same value, no matter the context in which it is called.
-	 * The value of {@link #toString(Event, boolean)} will be evaluated and captured for the literal's toString methods.
-	 *
-	 * @return A simplified literal with the data from this expression's evaluation.
-	 */
-	default Literal<T> getAsSimplifiedLiteral() {
-		return SimplifiedLiteral.fromExpression(this);
-	}
-
 	/**
 	 * Tests whether this expression supports the given mode, and if yes what type it expects the <code>delta</code> to be.
 	 * <p>

src/main/java/ch/njol/skript/lang/util/ConvertedExpression.java

@@ -265,6 +265,7 @@ public Expression<?> getSource() {
 
 	@Override
 	public Expression<? extends T> simplify() {
+		source = source.simplify();
 		return this;
 	}
 

src/main/java/ch/njol/skript/util/Direction.java

@@ -420,7 +420,37 @@ public String toString(final @Nullable Event e, final boolean debug) {
 			@Override
 			public Expression<? extends Location> simplify() {
 				if (dirs instanceof Literal && dirs.isSingle() && Direction.ZERO.equals(((Literal<?>) dirs).getSingle())) {
-					return locs;
+					return new SimpleExpression<>() {
+						@Override
+						public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+							throw new UnsupportedOperationException();
+						}
+
+						@Override
+						protected Location @Nullable [] get(Event event) {
+							return locs.getAll(event);
+						}
+
+						@Override
+						public boolean getAnd() {
+							return locs.getAnd();
+						}
+
+						@Override
+						public boolean isSingle() {
+							return locs.isSingle();
+						}
+
+						@Override
+						public Class<? extends Location> getReturnType() {
+							return Location.class;
+						}
+
+						@Override
+						public String toString(@Nullable Event event, boolean debug) {
+							return "at " + locs.toString(event, debug);
+						}
+					};
 				}
 				return this;
 			}

src/main/java/org/skriptlang/skript/lang/simplification/Simplifiable.java

@@ -15,6 +15,11 @@ public interface Simplifiable<S extends SyntaxElement> {
 	 * Any returned object should attempt to maintain the original value of {@link Debuggable#toString(Event, boolean)}.
 	 * An addition indicating that the value was simplified can be added in the debug string. See {@link SimplifiedLiteral}
 	 * for an example.
+	 * <br>
+	 * Simplification should never widen contracts. For example, any simplified expression should take care to return
+	 * the same or a more specific type than the original expression, never a more generic type. Likewise, be sure to
+	 * maintain the behavior of change() and acceptsChange(). Failure to do so can result in unexpected behavior and
+	 * tricky bugs.
 	 *
 	 * @return the simplified object.
 	 * @see SimplifiedLiteral

src/main/java/org/skriptlang/skript/lang/simplification/SimplifiedLiteral.java

@@ -14,6 +14,15 @@
  */
 public class SimplifiedLiteral<T> extends SimpleLiteral<T> {
 
+	/**
+	 * Creates a new simplified literal from an expression by evaluating it with a {@link ContextlessEvent}.
+	 * Any expression that requires specific event data cannot be safely simplified to a literal.
+	 * The original expression is stored for later toString generation.
+	 *
+	 * @param original the original expression to simplify
+	 * @param <T> the type of the literal
+	 * @return a new simplified literal
+	 */
 	public static <T> SimplifiedLiteral<T> fromExpression(Expression<T> original) {
 		Event event = ContextlessEvent.get();