Secspressions!

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

@@ -0,0 +1,171 @@
+package ch.njol.skript.expressions.base;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.config.SectionNode;
+import ch.njol.skript.lang.*;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.parser.ParserInstance;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * An implementation of the {@link Expression} interface that is allowed to start a section.
+ * <pre>{@code
+ * 	set {var} to (my section expression):
+ *      this is inside a section
+ *      this section can be 'managed' by (my section expression)
+ * }</pre>
+ * <br/>
+ * <br/>
+ * A section expression can be used in any expression slot, provided that:
+ * <ol>
+ *     <li>The line itself is not already a {@link Section} or an {@link EffectSection}.</li>
+ *     <li>The line does not already contain another {@link SectionExpression}.</li>
+ * </ol>
+ * <br/>
+ * <br/>
+ * The intended purpose of section expressions is to make features like the below possible,
+ * without the need to modify individual effect classes:
+ * <pre>{@code
+ * 	set {var} to a new lambda:
+ *      broadcast "hello"
+ *      # this section is managed by `a new lambda` rather than EffChange
+ * }</pre>
+ * <br/>
+ * <br/>
+ * Please note that section expressions will not be given a {@link SectionNode} during `init`
+ * if they are used in a line <b>that does not start a section</b>!
+ * It is up to the implementation to check whether this is provided.
+ * <p>
+ * Section node provided:
+ * <pre>{@code
+ * 	set {var} to a new lambda:
+ *      broadcast "hello"
+ * }</pre>
+ * <p>
+ * Section node not provided:
+ * <pre>{@code
+ * 	set {var} to a new lambda
+ * }</pre>
+ * <br/>
+ * <br/>
+ * Please also note that expressions are not 'executed' individually as effects/sections are,
+ * and so some behaviour (such as trigger items, orders, etc.) may be different from a regular section.
+ *
+ * @see Skript#registerExpression(Class, Class, ExpressionType, String...)
+ * @see Section
+ * @see SimpleExpression
+ */
+public abstract class SectionExpression<Value> extends SimpleExpression<Value> implements Expression<Value> {
+
+	protected final ExpressionSection section = new ExpressionSection(this);
+
+	/**
+	 * Called just after the constructor.
+	 *
+	 * @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
+	 * @param pattern The index of the pattern which matched
+	 * @param delayed Whether this expression is used after a delay or not (i.e. if the event has already passed when this expression will be called)
+	 * @param result Additional information about the match
+	 * @param node The section node representing the un-handled code in the body of the approaching section. If this expression does not start a section, the node will be null.
+	 * @param triggerItems A list of preceding trigger nodes before this line
+	 *
+	 * @return Whether this expression was initialised successfully. An error should be printed prior to returning false to specify the cause.
+	 */
+	public abstract boolean init(Expression<?>[] expressions,
+								 int pattern,
+								 Kleenean delayed,
+								 ParseResult result,
+								 @Nullable SectionNode node,
+								 @Nullable List<TriggerItem> triggerItems);
+
+	@Override
+	public final boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed,
+                              ParseResult parseResult) {
+		return section.init(expressions, matchedPattern, isDelayed, parseResult);
+	}
+
+	/**
+	 * @return A dummy trigger item representing the section belonging to this
+	 */
+	public final Section getAsSection() {
+		return section;
+	}
+
+	/**
+	 * Loads the code in the given {@link SectionNode},
+	 * appropriately modifying {@link ParserInstance#getCurrentSections()}.
+	 * <br>
+	 * This method differs from {@link #loadCode(SectionNode)} in that it
+	 * is meant for code that will be executed at another time and potentially with different context.
+	 * The section's contents are parsed with the understanding that they have no relation
+	 *  to the section itself, along with any other code that may come before and after the section.
+	 * The {@link ParserInstance} is modified to reflect that understanding.
+	 *
+	 * @param sectionNode The section node to load.
+	 * @param name The name of the event(s) being used.
+	 * @param afterLoading A Runnable to execute after the SectionNode has been loaded.
+	 * This occurs before {@link ParserInstance} states are reset.
+	 * @param events The event(s) during the section's execution.
+	 * @return A trigger containing the loaded section. This should be stored and used
+	 * to run the section one or more times.
+	 */
+	protected Trigger loadCode(SectionNode sectionNode, String name,
+							   @Nullable Runnable afterLoading, Class<? extends Event>... events) {
+		return section.loadCodeTask(sectionNode, name, afterLoading, events);
+	}
+
+	/**
+	 * Loads the code in the given {@link SectionNode},
+	 * appropriately modifying {@link ParserInstance#getCurrentSections()}.
+	 * <br>
+	 * This method itself does not modify {@link ParserInstance#getHasDelayBefore()}
+	 * (although the loaded code may change it), the calling code must deal with this.
+	 */
+	protected void loadCode(SectionNode sectionNode) {
+		this.section.loadCode(sectionNode);
+	}
+
+	/**
+	 * Loads the code using {@link #loadCode(SectionNode)}.
+	 * <br>
+	 * This method also adjusts {@link ParserInstance#getHasDelayBefore()} to expect the code
+	 * to be called zero or more times. This is done by setting {@code hasDelayBefore} to {@link Kleenean#UNKNOWN}
+	 * if the loaded section has a possible or definite delay in it.
+	 */
+	protected void loadOptionalCode(SectionNode sectionNode) {
+		this.section.loadOptionalCode(sectionNode);
+	}
+
+	/**
+	 * Remember to add this section to {@link ParserInstance#getCurrentSections()} before parsing child elements!
+	 *
+	 * <pre>{@code
+	 * ScriptLoader.currentSections.add(this);
+	 * setTriggerItems(ScriptLoader.loadItems(node));
+	 * ScriptLoader.currentSections.remove(ScriptLoader.currentSections.size() - 1);
+	 * }</pre>
+	 */
+	protected void setTriggerItems(List<TriggerItem> items) {
+		this.section.setTriggerItems(items);
+	}
+
+	protected TriggerSection setNext(@Nullable TriggerItem next) {
+		return this.section.setNext(next);
+	}
+
+	protected TriggerSection setParent(@Nullable TriggerSection parent) {
+		return this.section.setParent(parent);
+	}
+
+	protected @Nullable TriggerItem getNext() {
+		return this.section.getNext();
+	}
+
+}
+

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

@@ -0,0 +1,99 @@
+package ch.njol.skript.lang;
+
+import ch.njol.skript.config.SectionNode;
+import ch.njol.skript.expressions.base.SectionExpression;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * A dummy trigger item representing the 'section' aspect of a {@link SectionExpression}.
+ * This is not a parsed or registered syntax in itself, and can be used for getting access to the parse-time features
+ * of a section syntax (e.g. loading body code).
+ * <p>
+ * This is not safe to be used during runtime, since it is not a part of the trigger item tree.
+ *
+ * @see SectionExpression
+ * @see Section
+ * @see EffectSectionEffect
+ */
+@ApiStatus.Internal
+public class ExpressionSection extends Section {
+
+	protected final SectionExpression<?> expression;
+
+	public ExpressionSection(SectionExpression<?> expression) {
+		this.expression = expression;
+	}
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
+		SectionContext context = getParser().getData(SectionContext.class);
+		return this.init(expressions, matchedPattern, isDelayed, parseResult, context.sectionNode, context.triggerItems)
+			&& context.claim(expression);
+	}
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed,
+						SkriptParser.ParseResult parseResult,
+						@Nullable SectionNode sectionNode, List<TriggerItem> triggerItems) {
+		return expression.init(expressions, matchedPattern, isDelayed, parseResult, sectionNode, triggerItems);
+	}
+
+	@Override
+	protected @Nullable TriggerItem walk(Event event) {
+		return super.walk(event, false);
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return expression.toString(event, debug);
+	}
+
+	public SectionExpression<?> getAsExpression() {
+		return expression;
+	}
+
+	@Override
+	public void loadCode(SectionNode sectionNode) {
+		super.loadCode(sectionNode);
+	}
+
+	@Override
+	public void loadOptionalCode(SectionNode sectionNode) {
+		super.loadOptionalCode(sectionNode);
+	}
+
+	@Override
+	public void setTriggerItems(List<TriggerItem> items) {
+		super.setTriggerItems(items);
+	}
+
+	@Override
+	public TriggerSection setNext(@Nullable TriggerItem next) {
+		return super.setNext(next);
+	}
+
+	@Override
+	public TriggerSection setParent(@Nullable TriggerSection parent) {
+		return super.setParent(parent);
+	}
+
+	@Override
+	public @Nullable TriggerItem getNext() {
+		return super.getNext();
+	}
+
+	public Trigger loadCodeTask(SectionNode sectionNode, String name, @Nullable Runnable afterLoading, Class<? extends Event>... events) {
+		return super.loadCode(sectionNode, name, afterLoading, events);
+	}
+
+	@ApiStatus.Internal
+	protected boolean canInitSafely() {
+		return this.getParser().getData(SectionContext.class).claim(expression);
+	}
+
+}

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

@@ -25,6 +25,7 @@
 import ch.njol.skript.lang.parser.ParserInstance;
 import ch.njol.util.Kleenean;
 import org.bukkit.event.Event;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
@@ -64,7 +65,8 @@ public abstract class Section extends TriggerSection implements SyntaxElement {
 	@Override
 	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
 		SectionContext sectionContext = getParser().getData(SectionContext.class);
-		return init(expressions, matchedPattern, isDelayed, parseResult, sectionContext.sectionNode, sectionContext.triggerItems);
+		return init(expressions, matchedPattern, isDelayed, parseResult, sectionContext.sectionNode, sectionContext.triggerItems)
+			&& sectionContext.claim(this);
 	}
 
 	public abstract boolean init(Expression<?>[] expressions,
@@ -188,6 +190,7 @@ protected static class SectionContext extends ParserInstance.Data {
 
 		protected SectionNode sectionNode;
 		protected List<TriggerItem> triggerItems;
+		protected @Nullable Debuggable owner;
 
 		public SectionContext(ParserInstance parserInstance) {
 			super(parserInstance);
@@ -205,18 +208,59 @@ public SectionContext(ParserInstance parserInstance) {
 		protected <T> T modify(SectionNode sectionNode, List<TriggerItem> triggerItems, Supplier<T> supplier) {
 			SectionNode prevSectionNode = this.sectionNode;
 			List<TriggerItem> prevTriggerItems = this.triggerItems;
+			Debuggable owner = this.owner;
 
 			this.sectionNode = sectionNode;
 			this.triggerItems = triggerItems;
+			this.owner = null;
 
 			T result = supplier.get();
 
 			this.sectionNode = prevSectionNode;
 			this.triggerItems = prevTriggerItems;
+			this.owner = owner;
 
 			return result;
 		}
 
+		/**
+		 * Marks the section this context represents as having been 'claimed' by the current syntax.
+		 * Once a syntax has claimed a section, another syntax may not claim it.
+		 *
+		 * @param syntax The syntax that wants to own this section
+		 * @return True if this was successfully claimed, false if it was already owned
+		 */
+		@ApiStatus.Internal
+		public <Syntax extends SyntaxElement & Debuggable> boolean claim(Syntax syntax) {
+			if (sectionNode == null)
+				return true;
+			if (this.claimed()) {
+				if (owner == syntax)
+					return true;
+				assert owner != null;
+				Skript.error("The syntax '" + syntax.toString(null, false)
+					+ "' tried to claim the current section, but it was already claimed by '"
+					+ this.owner.toString(null, false)
+					+ "'. You cannot have two section-starters in the same line.");
+				return false;
+			}
+			this.owner = syntax;
+			return true;
+		}
+
+		/**
+		 * Used to keep track of whether a syntax is managing the current section.
+		 * Every section needs exactly one manager. This is used to detect errors such as:
+		 * <ol>
+		 *     <li>Two syntax both want to manage the section (e.g. an effectsection and an expression or two expressions).</li>
+		 *     <li>No syntax wants to manage the section.</li>
+		 * </ol>
+		 * @return Whether a syntax is already managing this section context
+		 */
+		public boolean claimed() {
+			return owner != null;
+		}
+
 	}
 
 }