Skip to content

Improve return types for ExprExpression and ExprChangeValue #157

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
sovdeeth merged 3 commits into from
Feb 1, 2026
+59 −279
Merged

Improve return types for ExprExpression and ExprChangeValue #157

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
e98de32
Improve return types for ExprExpression, ExprChangeValue
APickledWalrus Jan 2, 2026
9108522
nevermind it's more complicated
APickledWalrus Jan 2, 2026
73224ca
Merge branch '2.x' into patch/expression-return-types
sovdeeth Feb 1, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
165 changes: 27 additions & 138 deletions src/main/java/com/btk5h/skriptmirror/skript/custom/ExprExpression.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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,
Expand All @@ -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];
}
Expand All @@ -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);
}

}
8 changes: 4 additions & 4 deletions src/main/java/com/btk5h/skriptmirror/skript/custom/ExprRawExpression.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand All @@ -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);
Expand Down
Loading