Improve return types for ExprExpression and ExprChangeValue (#157)

* Improve return types for ExprExpression, ExprChangeValue

* nevermind it's more complicated

Author: APickledWalrus

src/main/java/com/btk5h/skriptmirror/skript/custom/ExprExpression.java

@@ -1,64 +1,36 @@
 package com.btk5h.skriptmirror.skript.custom;
 
 import ch.njol.skript.Skript;
-import ch.njol.skript.classes.Changer;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.ExpressionType;
-import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.lang.util.SimpleExpression;
-import ch.njol.skript.log.ErrorQuality;
 import ch.njol.skript.util.Utils;
-import ch.njol.util.Checker;
 import ch.njol.util.Kleenean;
-import ch.njol.util.coll.iterator.ArrayIterator;
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.reflect.syntax.condition.ConditionCheckEvent;
 import org.skriptlang.reflect.syntax.effect.EffectTriggerEvent;
 import org.skriptlang.reflect.syntax.event.EventTriggerEvent;
 import org.skriptlang.reflect.syntax.expression.ExpressionChangeEvent;
 import org.skriptlang.reflect.syntax.expression.ExpressionGetEvent;
-import com.btk5h.skriptmirror.util.JavaUtil;
 import org.bukkit.event.Event;
-import org.skriptlang.skript.lang.converter.Converters;
 
-import java.util.Iterator;
-import java.util.function.Predicate;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+public class ExprExpression extends SimpleExpression<Object> {
 
-public class ExprExpression<T> implements Expression<T> {
 	static {
-		//noinspection unchecked
 		Skript.registerExpression(ExprExpression.class, Object.class, ExpressionType.SIMPLE,
-			"[the] expr[ession][(1¦s)](-| )<\\d+>");
+			"[the] expr[ession][plural:s](-| )<\\d+>");
 	}
 
 	private int index;
-	private boolean plural;
-
-	private final ExprExpression<?> source;
-	private final Class<? extends T>[] types;
-	private final Class<T> superType;
-
-	@SuppressWarnings("unchecked")
-	public ExprExpression() {
-		this(null, ((Class<? extends T>) Object.class));
-	}
-
-	@SuppressWarnings("unchecked")
-	@SafeVarargs
-	private ExprExpression(ExprExpression<?> source, Class<? extends T>... types) {
-		if (source != null) {
-			index = source.index;
-			plural = source.plural;
-		}
-
-		this.source = source;
-		this.types = types;
-		this.superType = (Class<T>) Utils.getSuperType(types);
-	}
+	private boolean isPlural;
+	private Class<?> returnType;
 
 	@Override
-	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed,
-						SkriptParser.ParseResult parseResult) {
+	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
 		if (!getParser().isCurrentEvent(
 			SyntaxParseEvent.class,
 			ConditionCheckEvent.class,
@@ -67,51 +39,38 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 			ExpressionChangeEvent.class,
 			ExpressionGetEvent.class
 		)) {
-			Skript.error("The expression 'expression' may only be used in a custom syntax.",
-				ErrorQuality.SEMANTIC_ERROR);
+			Skript.error("The expression 'expression' may only be used in a custom syntax structure");
 			return false;
 		}
 
-		index = Utils.parseInt(parseResult.regexes.get(0).group(0));
+		index = Utils.parseInt(parseResult.regexes.getFirst().group(0));
 		if (index <= 0) {
-			Skript.error("The expression index must be a natural number.", ErrorQuality.SEMANTIC_ERROR);
+			Skript.error("The expression index must be a natural number");
 			return false;
 		}
 		index--;
 
-		plural = parseResult.mark == 1;
+		isPlural = parseResult.hasTag("plural");
 
-		return true;
-	}
-
-	@Override
-	public T getSingle(Event e) {
-		T[] all = getAll(e);
-		if (all.length == 0) {
-			return null;
-		}
-		return all[0];
-	}
+		// TODO better return types
+		returnType = Object.class;
 
-	@Override
-	public T[] getArray(Event e) {
-		return getAll(e);
+		return true;
 	}
 
 	@Override
-	public T[] getAll(Event e) {
-		Expression<?> expr = getExpression(e);
-
+	protected Object @Nullable [] get(Event event) {
+		Expression<?> expr = getExpression(event);
 		if (expr == null) {
-			return JavaUtil.newArray(superType, 0);
+			return (Object[]) Array.newInstance(getReturnType(), 0);
 		}
-
-		return Converters.convert(expr.getAll(e), types, superType);
+		Object[] values = expr.getAll(event);
+		return Arrays.copyOf(values, values.length, (Class<? extends Object[]>) getReturnType().arrayType());
 	}
 
 	@Nullable
-	Expression<?> getExpression(Event e) {
-		Expression<?>[] expressions = ((CustomSyntaxEvent) e).getExpressions();
+	Expression<?> getExpression(Event event) {
+		Expression<?>[] expressions = ((CustomSyntaxEvent) event).getExpressions();
 		if (index < expressions.length) {
 			return expressions[index];
 		}
@@ -120,87 +79,17 @@ Expression<?> getExpression(Event e) {
 
 	@Override
 	public boolean isSingle() {
-		return !plural;
-	}
-
-	@Override
-	public boolean check(Event e, Predicate<? super T> c, boolean negated) {
-		return SimpleExpression.check(getAll(e), c, negated, getAnd());
-	}
-
-	@Override
-	public boolean check(Event e, Predicate<? super T> c) {
-		return SimpleExpression.check(getAll(e), c, false, getAnd());
-	}
-
-	@Override
-	public <R> Expression<? extends R> getConvertedExpression(Class<R>[] to) {
-		return new ExprExpression<>(this, to);
-	}
-
-	@Override
-	public Class<? extends T> getReturnType() {
-		return superType;
-	}
-
-	@Override
-	public boolean getAnd() {
-		return true;
-	}
-
-	@Override
-	public boolean setTime(int time) {
-		return false;
-	}
-
-	@Override
-	public int getTime() {
-		return 0;
-	}
-
-	@Override
-	public boolean isDefault() {
-		return false;
+		return !isPlural;
 	}
 
 	@Override
-	public Iterator<? extends T> iterator(Event e) {
-		return new ArrayIterator<>(getAll(e));
+	public Class<?> getReturnType() {
+		return returnType;
 	}
 
 	@Override
-	public boolean isLoopOf(String s) {
-		return s.equalsIgnoreCase("expression");
-	}
-
-	@Override
-	public Expression<?> getSource() {
-		return source == null ? this : source;
-	}
-
-	@Override
-	public Expression<? extends T> simplify() {
-		return this;
-	}
-
-	@Override
-	public Class<?>[] acceptChange(Changer.ChangeMode mode) {
-		return null;
-	}
-
-	@Override
-	public void change(Event e, Object[] delta, Changer.ChangeMode mode) {
-		throw new UnsupportedOperationException();
-	}
-
-	@Override
-	public String toString(Event e, boolean debug) {
+	public String toString(Event event, boolean debug) {
 		return "expression " + (index + 1);
 	}
 
-	@Override
-	public String toString() {
-		return toString(null, false);
-	}
-
 }

src/main/java/com/btk5h/skriptmirror/skript/custom/ExprRawExpression.java

@@ -34,7 +34,7 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 	@Override
 	protected Expression<?>[] get(Event event) {
 		Expression<?> expr = this.expr;
-		if (expr instanceof ExprExpression<?> exprExpr && event instanceof CustomSyntaxEvent) {
+		if (expr instanceof ExprExpression exprExpr && event instanceof CustomSyntaxEvent) {
 			expr = exprExpr.getExpression(event);
 			if (expr == null)
 				return null;
@@ -50,15 +50,15 @@ public Class<?>[] acceptChange(ChangeMode changeMode) {
 
 	@Override
 	public void change(Event event, Object[] delta, ChangeMode changeMode) {
-		if (!(expr instanceof ExprExpression && event instanceof CustomSyntaxEvent))
+		if (!(expr instanceof ExprExpression exprExpression && event instanceof CustomSyntaxEvent customEvent))
 			return;
 
-		Expression<?> expr = ((ExprExpression<?>) this.expr).getExpression(event);
+		Expression<?> expr = exprExpression.getExpression(event);
 		if (expr == null)
 			return;
 		Expression<?> source = expr.getSource();
 
-		Event unwrappedEvent = ((WrappedEvent) event).getDirectEvent();
+		Event unwrappedEvent = customEvent.getDirectEvent();
 		// Ensure acceptChange has been called before change
 		try {
 			source.acceptChange(changeMode);