Secspressions!

src/main/java/ch/njol/skript/ScriptLoader.java

@@ -28,11 +28,9 @@
 import ch.njol.skript.lang.Statement;
 import ch.njol.skript.lang.TriggerItem;
 import ch.njol.skript.lang.TriggerSection;
+import ch.njol.skript.lang.function.EffFunctionCall;
 import ch.njol.skript.lang.parser.ParserInstance;
-import ch.njol.skript.log.CountingLogHandler;
-import ch.njol.skript.log.LogEntry;
-import ch.njol.skript.log.RetainingLogHandler;
-import ch.njol.skript.log.SkriptLogger;
+import ch.njol.skript.log.*;
 import ch.njol.skript.sections.SecLoop;
 import ch.njol.skript.structures.StructOptions.OptionsData;
 import ch.njol.skript.util.ExceptionUtils;
@@ -56,16 +54,7 @@
 import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
+import java.util.*;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
@@ -984,9 +973,38 @@ public static ArrayList<TriggerItem> loadItems(SectionNode node) {
 			} else if (subNode instanceof SectionNode) {
 				TypeHints.enterScope(); // Begin conditional type hints
 
-				Section section = Section.parse(expr, "Can't understand this section: " + expr, (SectionNode) subNode, items);
-				if (section == null)
+				TriggerItem section;
+				RetainingLogHandler handler = SkriptLogger.startRetainingLog();
+				find_section:
+				try {
+					section = Section.parse(expr, "Can't understand this section: " + expr, (SectionNode) subNode, items);
+					if (section != null)
+						break find_section;
+
+					// back up the failure log
+					RetainingLogHandler backup = handler.backup();
+					handler.clear();
+
+					section = Statement.parse(expr, "Can't understand this effect: " + expr, (SectionNode) subNode, items);
+
+					if (section != null)
+						break find_section;
+					Collection<LogEntry> errors = handler.getErrors();
+
+					// restore the failure log
+					if (errors.isEmpty()) {
+						handler.restore(backup);
+					} else { // We specifically want these two errors in preference to the section error!
+						String firstError = errors.iterator().next().getMessage();
+						if (!firstError.contains("is a valid statement but cannot function as a section (:)")
+							&& !firstError.contains("You cannot have two section-starters in the same line"))
+							handler.restore(backup);
+					}
 					continue;
+				} finally {
+					handler.printLog();
+					handler.close();
+				}
 
 				if (Skript.debug() || subNode.debug())
 					Skript.debug(SkriptColor.replaceColorChar(parser.getIndentation() + section.toString(null, true)));

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);
+	}
+
+}