Adds a preinit() method to SyntaxElement (#7778)

* pre-init method

* fix merge mistakes

* Update SkriptParser.java

Author: sovdeeth

src/main/java/ch/njol/skript/expressions/base/SimplePropertyExpression.java

@@ -1,13 +1,11 @@
 package ch.njol.skript.expressions.base;
 
-import ch.njol.skript.config.Node;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.util.LiteralUtils;
 import ch.njol.util.Kleenean;
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.Nullable;
-import org.skriptlang.skript.log.runtime.SyntaxRuntimeErrorProducer;
 import org.skriptlang.skript.lang.converter.Converter;
 
 /**
@@ -16,9 +14,8 @@
  * @see PropertyExpression
  * @see PropertyExpression#register(Class, Class, String, String)
  */
-public abstract class SimplePropertyExpression<F, T> extends PropertyExpression<F, T> implements Converter<F, T>, SyntaxRuntimeErrorProducer {
+public abstract class SimplePropertyExpression<F, T> extends PropertyExpression<F, T> implements Converter<F, T> {
 
-	private Node node;
 	protected String rawExpr;
 
 	@Override
@@ -29,7 +26,6 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean is
 			return LiteralUtils.canInitSafely(getExpr());
 		}
 		setExpr((Expression<? extends F>) expressions[0]);
-		node = getParser().getNode();
 		rawExpr = parseResult.expr;
 		return true;
 	}
@@ -43,11 +39,6 @@ protected T[] get(Event event, F[] source) {
 		return super.get(source, this);
 	}
 
-	@Override
-	public Node getNode() {
-		return node;
-	}
-
 	/**
 	 * Used to collect the property type used in the register method.
 	 * This forms the toString of this SimplePropertyExpression.

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

@@ -43,6 +43,7 @@
 import org.skriptlang.skript.lang.script.Script;
 import org.skriptlang.skript.lang.script.ScriptWarning;
 
+import java.lang.reflect.Array;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -52,7 +53,6 @@
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
 import java.util.stream.Stream;
-import java.lang.reflect.Array;
 
 /**
  * Used for parsing my custom patterns.<br>
@@ -237,19 +237,13 @@ public boolean hasTag(String tag) {
 							}
 							T element = info.getElementClass().newInstance();
 
-							if (element instanceof EventRestrictedSyntax eventRestrictedSyntax) {
-								Class<? extends Event>[] supportedEvents = eventRestrictedSyntax.supportedEvents();
-								if (!getParser().isCurrentEvent(supportedEvents)) {
-									Skript.error("'" + parseResult.expr + "' can only be used in " + supportedEventsNames(supportedEvents));
-									continue;
-								}
-							}
-							if (element instanceof ExperimentalSyntax experimentalSyntax) {
-								if (!experimentalSyntax.isSatisfiedBy(getParser().getExperimentSet()))
-									continue;
-							}
+							if (!checkRestrictedEvents(element, parseResult))
+								continue;
+
+							if (!checkExperimentalSyntax(element))
+								continue;
 
-							boolean success = element.init(parseResult.exprs, patternIndex, getParser().getHasDelayBefore(), parseResult);
+							boolean success = element.preInit() && element.init(parseResult.exprs, patternIndex, getParser().getHasDelayBefore(), parseResult);
 							if (success) {
 								log.printLog();
 								return element;
@@ -267,7 +261,31 @@ public boolean hasTag(String tag) {
 		}
 	}
 
-	private static String supportedEventsNames(Class<? extends Event>[] supportedEvents) {
+	/**
+	 * Checks whether the given element is restricted to specific events, and if so, whether the current event is allowed.
+	 * Prints errors.
+	 * @param element The syntax element to check.
+	 * @param parseResult The parse result for error information.
+	 * @return True if the element is allowed in the current event, false otherwise.
+	 */
+	private static boolean checkRestrictedEvents(SyntaxElement element, ParseResult parseResult) {
+		if (element instanceof EventRestrictedSyntax eventRestrictedSyntax) {
+			Class<? extends Event>[] supportedEvents = eventRestrictedSyntax.supportedEvents();
+			if (!getParser().isCurrentEvent(supportedEvents)) {
+				Skript.error("'" + parseResult.expr + "' can only be used in " + supportedEventsNames(supportedEvents));
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Returns a string with the names of the supported skript events for the given class array.
+	 * If no events are found, returns an empty string.
+	 * @param supportedEvents The array of supported event classes.
+	 * @return A string with the names of the supported skript events, or an empty string if none are found.
+	 */
+	private static @NotNull String supportedEventsNames(Class<? extends Event>[] supportedEvents) {
 		List<String> names = new ArrayList<>();
 
 		for (SkriptEventInfo<?> eventInfo : Skript.getEvents()) {
@@ -283,6 +301,18 @@ private static String supportedEventsNames(Class<? extends Event>[] supportedEve
 		return StringUtils.join(names, ", ", " or ");
 	}
 
+	/**
+	 * Checks whether the given element is experimental and if so, whether the current experiment set satisfies it.
+	 * Prints errors.
+	 * @param element The syntax element to check.
+	 * @return True if the element is allowed in the current experiment set, false otherwise.
+	 */
+	private static boolean checkExperimentalSyntax(SyntaxElement element) {
+		if (element instanceof ExperimentalSyntax experimentalSyntax)
+			return experimentalSyntax.isSatisfiedBy(getParser().getExperimentSet());
+		return true;
+	}
+
 	private static @NotNull DefaultExpression<?> getDefaultExpression(ExprInfo exprInfo, String pattern) {
 		DefaultExpression<?> expr = exprInfo.classes[0].getDefaultExpression();
 		if (expr == null)

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

@@ -12,7 +12,19 @@
 public interface SyntaxElement {
 
 	/**
-	 * Called just after the constructor.
+	 * Called immediately after the constructor. This should be used to do any work that need to be done prior to
+	 * downstream initialization. This is not intended to be used by syntaxes directly, but by parent classes to do
+	 * work prior to the initialization of the child classes.
+	 *
+	 * @return Whether this expression was pre-initialised successfully.
+	 * 			An error should be printed prior to returning false to specify the cause.
+	 */
+	default boolean preInit() {
+		return true;
+	}
+
+	/**
+	 * Called just after the constructor and {@link #preInit}.
 	 * 
 	 * @param expressions all %expr%s included in the matching pattern in the order they appear in the pattern. If an optional value was left out, it will still be included in this list
 	 *            holding the default value of the desired type, which usually depends on the event.

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

@@ -5,6 +5,7 @@
 import ch.njol.skript.classes.Changer;
 import ch.njol.skript.classes.Changer.ChangeMode;
 import ch.njol.skript.classes.ClassInfo;
+import ch.njol.skript.config.Node;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.ExpressionType;
 import ch.njol.skript.lang.Loopable;
@@ -18,24 +19,31 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.lang.converter.Converter;
+import org.skriptlang.skript.log.runtime.SyntaxRuntimeErrorProducer;
 
 import java.lang.reflect.Array;
 import java.util.Arrays;
 import java.util.Iterator;
-import java.util.List;
 import java.util.function.Predicate;
 
 /**
  * An implementation of the {@link Expression} interface. You should usually extend this class to make a new expression.
  *
  * @see Skript#registerExpression(Class, Class, ExpressionType, String...)
  */
-public abstract class SimpleExpression<T> implements Expression<T> {
+public abstract class SimpleExpression<T> implements Expression<T>, SyntaxRuntimeErrorProducer {
 
 	private int time = 0;
+	private Node node;
 
 	protected SimpleExpression() {}
 
+	@Override
+	public boolean preInit() {
+		node = getParser().getNode();
+		return Expression.super.preInit();
+	}
+
 	@Override
 	public final @Nullable T getSingle(Event event) {
 		T[] values = getArray(event);
@@ -330,6 +338,11 @@ public Expression<?> getSource() {
 		return this;
 	}
 
+	@Override
+	public Node getNode() {
+		return node;
+	}
+
 	@Override
 	public Expression<? extends T> simplify() {
 		return this;
@@ -344,4 +357,5 @@ public boolean getAnd() {
 	public boolean supportsLoopPeeking() {
 		return true;
 	}
+
 }

src/main/java/org/skriptlang/skript/bukkit/tags/elements/ExprTag.java

@@ -1,13 +1,7 @@
 package org.skriptlang.skript.bukkit.tags.elements;
 
 import ch.njol.skript.Skript;
-import ch.njol.skript.config.Node;
-import ch.njol.skript.doc.Description;
-import ch.njol.skript.doc.Examples;
-import ch.njol.skript.doc.Keywords;
-import ch.njol.skript.doc.Name;
-import ch.njol.skript.doc.RequiredPlugins;
-import ch.njol.skript.doc.Since;
+import ch.njol.skript.doc.*;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.ExpressionType;
 import ch.njol.skript.lang.Literal;
@@ -23,7 +17,6 @@
 import org.skriptlang.skript.bukkit.tags.TagModule;
 import org.skriptlang.skript.bukkit.tags.TagType;
 import org.skriptlang.skript.bukkit.tags.sources.TagOrigin;
-import org.skriptlang.skript.log.runtime.SyntaxRuntimeErrorProducer;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -53,7 +46,7 @@
 @Since("2.10")
 @RequiredPlugins("Paper (paper tags)")
 @Keywords({"blocks", "minecraft tag", "type", "category"})
-public class ExprTag extends SimpleExpression<Tag> implements SyntaxRuntimeErrorProducer {
+public class ExprTag extends SimpleExpression<Tag> {
 
 	static {
 		Skript.registerExpression(ExprTag.class, Tag.class, ExpressionType.COMBINED,
@@ -65,16 +58,13 @@ public class ExprTag extends SimpleExpression<Tag> implements SyntaxRuntimeError
 	private TagOrigin origin;
 	private boolean datapackOnly;
 
-	private Node node;
-
 	@Override
 	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
 		//noinspection unchecked
 		names = (Expression<String>) expressions[0];
 		types = TagType.fromParseMark(parseResult.mark);
 		origin = TagOrigin.fromParseTags(parseResult.tags);
 		datapackOnly = origin == TagOrigin.BUKKIT && parseResult.hasTag("datapack");
-		node = getParser().getNode();
 		return true;
 	}
 
@@ -142,11 +132,6 @@ public Class<? extends Tag> getReturnType() {
 		return Tag.class;
 	}
 
-	@Override
-	public Node getNode() {
-		return node;
-	}
-
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
 		String registry = types.length > 1 ? "" : " " + types[0].toString();