Return API

src/main/java/ch/njol/skript/effects/EffReturn.java

@@ -30,17 +30,14 @@
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.lang.TriggerItem;
 import ch.njol.skript.lang.TriggerSection;
-import ch.njol.skript.lang.function.FunctionEvent;
-import ch.njol.skript.lang.function.Functions;
-import ch.njol.skript.lang.function.ScriptFunction;
 import ch.njol.skript.log.RetainingLogHandler;
 import ch.njol.skript.log.SkriptLogger;
 import ch.njol.util.Kleenean;
 import org.bukkit.event.Event;
 import org.eclipse.jdt.annotation.Nullable;
 
 @Name("Return")
-@Description("Makes a function return a value")
+@Description("Makes a trigger (e.g. a function) return a value")
 @Examples({
 	"function double(i: number) :: number:",
 		"\treturn 2 * {_i}",
@@ -50,70 +47,64 @@
 })
 @Since("2.2, INSERT VERSION (returns aliases)")
 public class EffReturn extends Effect {
-	
+
 	static {
 		Skript.registerEffect(EffReturn.class, "return %objects%");
 	}
-	
+
 	@SuppressWarnings("NotNullFieldNotInitialized")
-	private ScriptFunction<?> function;
-
+	private TriggerSection section;
 	@SuppressWarnings("NotNullFieldNotInitialized")
 	private Expression<?> value;
-
-	@SuppressWarnings("unchecked")
+
 	@Override
+	@SuppressWarnings("unchecked")
 	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
-		ScriptFunction<?> f = Functions.currentFunction;
-		if (f == null) {
-			Skript.error("The return statement can only be used in a function");
+		ReturnData data = getParser().getCurrentReturnData();
+		if (data == null) {
+			Skript.error("The return statement cannot be used here");
 			return false;
 		}
-		
+
 		if (!isDelayed.isFalse()) {
 			Skript.error("A return statement after a delay is useless, as the calling trigger will resume when the delay starts (and won't get any returned value)");
 			return false;
 		}
-		
-		function = f;
-		ClassInfo<?> returnType = function.getReturnType();
+
+		section = data.getSection();
+		ClassInfo<?> returnType = data.getReturnType();
 		if (returnType == null) {
-			Skript.error("This function doesn't return any value. Please use 'stop' or 'exit' if you want to stop the function.");
+			Skript.error("This trigger doesn't return any value. Please use 'stop' or 'exit' if you want to stop the function.");
 			return false;
 		}
-		
+
 		RetainingLogHandler log = SkriptLogger.startRetainingLog();
 		Expression<?> convertedExpr;
 		try {
 			convertedExpr = exprs[0].getConvertedExpression(returnType.getC());
 			if (convertedExpr == null) {
-				log.printErrors("This function is declared to return " + returnType.getName().withIndefiniteArticle() + ", but " + exprs[0].toString(null, false) + " is not of that type.");
+				log.printErrors("This trigger is declared to return " + returnType.getName().withIndefiniteArticle() + ", but " + exprs[0].toString(null, false) + " is not of that type.");
 				return false;
 			}
 			log.printLog();
 		} finally {
 			log.stop();
 		}
-		
-		if (f.isSingle() && !convertedExpr.isSingle()) {
-			Skript.error("This function is defined to only return a single " + returnType.toString() + ", but this return statement can return multiple values.");
+
+		if (data.isSingle() && !convertedExpr.isSingle()) {
+			Skript.error("This trigger is defined to only return a single " + returnType + ", but this return statement can return multiple values.");
 			return false;
 		}
 		value = convertedExpr;
-		
+
 		return true;
 	}
-	
+
 	@Override
 	@Nullable
-	@SuppressWarnings({"unchecked", "rawtypes"})
 	protected TriggerItem walk(Event event) {
 		debug(event, false);
-		if (event instanceof FunctionEvent) {
-			((ScriptFunction) function).setReturnValue(value.getArray(event));
-		} else {
-			assert false : event;
-		}
+		section.setReturnValue(value.getArray(event));
 
 		TriggerSection parent = getParent();
 		while (parent != null) {
@@ -125,15 +116,43 @@ protected TriggerItem walk(Event event) {
 
 		return null;
 	}
-	
+
 	@Override
 	protected void execute(Event event) {
 		assert false;
 	}
-	
+
 	@Override
 	public String toString(@Nullable Event event, boolean debug) {
 		return "return " + value.toString(event, debug);
 	}
-
+
+	public static class ReturnData {
+
+		private final TriggerSection section;
+		@Nullable
+		private final ClassInfo<?> returnType;
+		private final boolean single;
+
+		public ReturnData(TriggerSection section, @Nullable ClassInfo<?> returnType, boolean single) {
+			this.section = section;
+			this.returnType = returnType;
+			this.single = single;
+		}
+
+		public TriggerSection getSection() {
+			return section;
+		}
+
+		@Nullable
+		public ClassInfo<?> getReturnType() {
+			return returnType;
+		}
+
+		public boolean isSingle() {
+			return single;
+		}
+
+	}
+
 }

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

@@ -20,7 +20,9 @@
 
 import ch.njol.skript.ScriptLoader;
 import ch.njol.skript.Skript;
+import ch.njol.skript.classes.ClassInfo;
 import ch.njol.skript.config.SectionNode;
+import ch.njol.skript.effects.EffReturn.ReturnData;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.lang.parser.ParserInstance;
 import ch.njol.util.Kleenean;
@@ -29,15 +31,18 @@
 import org.skriptlang.skript.lang.structure.Structure;
 
 import java.util.ArrayList;
+import java.util.Deque;
 import java.util.Iterator;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.function.Supplier;
 
 /**
  * A section that can decide what it does with its contents, as code isn't parsed by default.
  * <br><br>
  * In most cases though, a section should load its code through one of the following loading methods:
- * {@link #loadCode(SectionNode)}, {@link #loadCode(SectionNode, String, Class[])}, {@link #loadOptionalCode(SectionNode)}
+ * {@link #loadCode(SectionNode)}, {@link #loadCode(SectionNode, String, Class[])}, {@link #loadOptionalCode(SectionNode)},
+ * {@link #loadReturnableCode(SectionNode, ClassInfo, boolean)}
  * <br><br>
  * Every section must override the {@link TriggerSection#walk(Event)} method. In this method, you can determine whether
  * or not the section should run. If you have stored a {@link Trigger} from {@link #loadCode(SectionNode, String, Class[])}, you
@@ -135,12 +140,14 @@ protected final Trigger loadCode(SectionNode sectionNode, String name, @Nullable
 		Structure previousStructure = parser.getCurrentStructure();
 		List<TriggerSection> previousSections = parser.getCurrentSections();
 		Kleenean previousDelay = parser.getHasDelayBefore();
+		Deque<ReturnData> previousReturnQueue = parser.getReturnStack();
 
 		parser.setCurrentEvent(name, events);
 		SkriptEvent skriptEvent = new SectionSkriptEvent(name, this);
 		parser.setCurrentStructure(skriptEvent);
 		parser.setCurrentSections(new ArrayList<>());
 		parser.setHasDelayBefore(Kleenean.FALSE);
+		parser.setReturnStack(new LinkedList<>());
 		List<TriggerItem> triggerItems = ScriptLoader.loadItems(sectionNode);
 
 		if (afterLoading != null)
@@ -151,6 +158,7 @@ protected final Trigger loadCode(SectionNode sectionNode, String name, @Nullable
 		parser.setCurrentStructure(previousStructure);
 		parser.setCurrentSections(previousSections);
 		parser.setHasDelayBefore(previousDelay);
+		parser.setReturnStack(previousReturnQueue);
 
 		return new Trigger(parser.getCurrentScript(), name, skriptEvent, triggerItems);
 	}
@@ -171,6 +179,23 @@ protected void loadOptionalCode(SectionNode sectionNode) {
 			getParser().setHasDelayBefore(Kleenean.UNKNOWN);
 	}
 
+	/**
+	 * Loads the code using {@link Section#loadCode(SectionNode)}.
+	 * <br>
+	 * This method also pushes the current trigger into the return stack,
+	 * and pops it once it's done loading.
+	 * @see ParserInstance#getReturnStack()
+	 * @see ParserInstance#pushReturnData(ReturnData)
+	 */
+	protected void loadReturnableCode(SectionNode sectionNode, @Nullable ClassInfo<?> returnType, boolean single) {
+		try {
+			getParser().pushReturnData(new ReturnData(this, returnType, single));
+			loadCode(sectionNode);
+		} finally {
+			getParser().popReturnData();
+		}
+	}
+
 	@SuppressWarnings({"unchecked", "rawtypes"})
 	@Nullable
 	public static Section parse(String expr, @Nullable String defaultError, SectionNode sectionNode, List<TriggerItem> triggerItems) {

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

@@ -24,6 +24,7 @@
 import org.eclipse.jdt.annotation.Nullable;
 
 import java.util.List;
+import java.util.function.Function;
 
 public class Trigger extends TriggerSection {
 
@@ -36,11 +37,15 @@ public class Trigger extends TriggerSection {
 	private String debugLabel;
 
 	public Trigger(@Nullable Script script, String name, SkriptEvent event, List<TriggerItem> items) {
-		super(items);
+		this(script, name, event, trigger -> items);
+	}
+
+	public Trigger(@Nullable Script script, String name, SkriptEvent event, Function<Trigger, List<TriggerItem>> function) {
 		this.script = script;
 		this.name = name;
 		this.event = event;
 		this.debugLabel = "unknown trigger";
+		setTriggerItems(function.apply(this));
 	}
 
 	/**

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

@@ -20,12 +20,14 @@
 
 import java.util.List;
 
+import ch.njol.util.coll.CollectionUtils;
 import org.bukkit.event.Event;
 import org.eclipse.jdt.annotation.Nullable;
 
 import ch.njol.skript.ScriptLoader;
 import ch.njol.skript.config.SectionNode;
 import ch.njol.skript.lang.parser.ParserInstance;
+import org.jetbrains.annotations.ApiStatus;
 
 /**
  * Represents a section of a trigger, e.g. a conditional or a loop
@@ -36,7 +38,10 @@ public abstract class TriggerSection extends TriggerItem {
 	protected TriggerItem first = null;
 	@Nullable
 	protected TriggerItem last = null;
-
+
+	private boolean returnValueSet = false;
+	private Object @Nullable [] returnValue;
+
 	/**
 	 * Reserved for new Trigger(...)
 	 */
@@ -93,7 +98,30 @@ public TriggerSection setParent(@Nullable TriggerSection parent) {
 		super.setParent(parent);
 		return this;
 	}
-
+
+	public Object @Nullable [] getReturnValue() {
+		return returnValue;
+	}
+
+	public <T> T @Nullable [] getReturnValue(Class<T> expectedType) {
+		return CollectionUtils.arrayType(expectedType).cast(getReturnValue());
+	}
+
+	/**
+	 * Should only be called by {@link ch.njol.skript.effects.EffReturn}.
+	 */
+	@ApiStatus.Internal
+	public final void setReturnValue(Object @Nullable [] returnValue) {
+		assert !returnValueSet;
+		returnValueSet = true;
+		this.returnValue = returnValue;
+	}
+
+	public final void resetReturnValue() {
+		returnValueSet = false;
+		returnValue = null;
+	}
+
 	@Override
 	protected final boolean run(Event e) {
 		throw new UnsupportedOperationException();

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

@@ -18,6 +18,7 @@
  */
 package ch.njol.skript.lang.function;
 
+import ch.njol.skript.lang.parser.ParserInstance;
 import org.skriptlang.skript.lang.script.Script;
 import org.eclipse.jdt.annotation.Nullable;
 
@@ -37,32 +38,33 @@ public class ScriptFunction<T> extends Function<T> {
 
 	public ScriptFunction(Signature<T> sign, Script script, SectionNode node) {
 		super(sign);
-
+
+		ParserInstance parser = ParserInstance.get();
 		Functions.currentFunction = this;
 		try {
 			trigger = new Trigger(
 				script,
 				"function " + sign.getName(),
 				new SimpleEvent(),
-				ScriptLoader.loadItems(node)
+				trigger -> {
+					parser.pushReturnData(trigger, getReturnType(), isSingle());
+					return ScriptLoader.loadItems(node);
+				}
 			);
-			trigger.setLineNumber(node.getLine());
 		} finally {
 			Functions.currentFunction = null;
+			parser.popReturnData();
 		}
+		trigger.setLineNumber(node.getLine());
 	}
 
-	private boolean returnValueSet = false;
-	@Nullable
-	private T[] returnValue = null;
-
 	/**
 	 * Should only be called by {@link EffReturn}.
+	 * @deprecated Use {@link ch.njol.skript.lang.TriggerSection#setReturnValue(Object[])}
 	 */
+	@Deprecated
 	public final void setReturnValue(final @Nullable T[] value) {
-		assert !returnValueSet;
-		returnValueSet = true;
-		returnValue = value;
+		trigger.setReturnValue(value);
 	}
 
 	// REMIND track possible types of local variables (including undefined variables) (consider functions, commands, and EffChange) - maybe make a general interface for this purpose
@@ -84,13 +86,12 @@ public T[] execute(final FunctionEvent<?> e, final Object[][] params) {
 		}
 
 		trigger.execute(e);
-		return returnValue;
+		return getReturnType() == null ? null : trigger.getReturnValue(getReturnType().getC());
 	}
 
 	@Override
 	public boolean resetReturnValue() {
-		returnValue = null;
-		returnValueSet = false;
+		trigger.resetReturnValue();
 		return true;
 	}