Merge branch 'dev/patch' into dev/feature

Author: APickledWalrus

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

@@ -23,6 +23,10 @@
  */
 public abstract class EffectSection extends Section {
 
+	static {
+		ParserInstance.registerData(EffectSectionContext.class, EffectSectionContext::new);
+	}
+
 	private boolean hasSection;
 
 	public boolean hasSection() {
@@ -34,10 +38,23 @@ public boolean hasSection() {
 	 */
 	@Override
 	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
-		SectionContext sectionContext = getParser().getData(SectionContext.class);
+		ParserInstance parser = getParser();
+		SectionContext sectionContext = parser.getData(SectionContext.class);
+		EffectSectionContext effectSectionContext = parser.getData(EffectSectionContext.class);
+		SectionNode sectionNode = sectionContext.sectionNode;
+		if (!effectSectionContext.isNodeForEffectSection) {
+			sectionContext.sectionNode = null;
+		}
+
 		//noinspection ConstantConditions - For an EffectSection, it may be null
 		hasSection = sectionContext.sectionNode != null;
-		return super.init(expressions, matchedPattern, isDelayed, parseResult);
+		boolean result = super.init(expressions, matchedPattern, isDelayed, parseResult);
+
+		if (!effectSectionContext.isNodeForEffectSection) {
+			sectionContext.sectionNode = sectionNode;
+		}
+
+		return result;
 	}
 
 	@Override
@@ -52,15 +69,48 @@ public abstract boolean init(Expression<?>[] expressions,
 	 * Similar to {@link Section#parse(String, String, SectionNode, List)}, but will only attempt to parse from other {@link EffectSection}s.
 	 */
 	public static @Nullable EffectSection parse(String input, @Nullable String defaultError, @Nullable SectionNode sectionNode, @Nullable List<TriggerItem> triggerItems) {
-		SectionContext sectionContext = ParserInstance.get().getData(SectionContext.class);
+		return parse(input, defaultError, sectionNode, true,  triggerItems);
+	}
+
+	/**
+	 * Similar to {@link Section#parse(String, String, SectionNode, List)}, but will only attempt to parse from other {@link EffectSection}s.
+	 * @param isNodeForEffectSection Whether {@code sectionNode} can be {@link SectionContext#claim(SyntaxElement)}-ed by the parsed EffectSection.
+	 */
+	public static @Nullable EffectSection parse(String input, @Nullable String defaultError, SectionNode sectionNode, boolean isNodeForEffectSection, List<TriggerItem> triggerItems) {
+		ParserInstance parser = ParserInstance.get();
+		SectionContext sectionContext = parser.getData(SectionContext.class);
+		EffectSectionContext effectSectionContext = parser.getData(EffectSectionContext.class);
+		boolean wasNodeForEffectSection = effectSectionContext.isNodeForEffectSection;
+		effectSectionContext.isNodeForEffectSection = isNodeForEffectSection;
 
-		return sectionContext.modify(sectionNode, triggerItems, () -> {
+		EffectSection effectSection = sectionContext.modify(sectionNode, triggerItems, () -> {
 			var iterator = Skript.instance().syntaxRegistry().syntaxes(org.skriptlang.skript.registration.SyntaxRegistry.SECTION).stream()
-					.filter(info -> EffectSection.class.isAssignableFrom(info.type()))
-					.iterator();
+				.filter(info -> EffectSection.class.isAssignableFrom(info.type()))
+				.iterator();
 			//noinspection unchecked,rawtypes
-			return (EffectSection) SkriptParser.parse(input, (Iterator) iterator, defaultError);
+			EffectSection parsed = (EffectSection) SkriptParser.parse(input, (Iterator) iterator, defaultError);
+			if (parsed != null && sectionNode != null && !sectionContext.claimed()) {
+				Skript.error("The line '" + input + "' is a valid statement but cannot function as a section (:) because there is no syntax in the line to manage it.");
+				return null;
+			}
+			return parsed;
 		});
+
+		effectSectionContext.isNodeForEffectSection = wasNodeForEffectSection;
+		return effectSection;
+	}
+
+	private static class EffectSectionContext extends ParserInstance.Data {
+
+		/**
+		 * Whether the {@link SectionContext#sectionNode} can be used by the initializing {@link EffectSection}.
+		 */
+		public boolean isNodeForEffectSection = true;
+
+		public EffectSectionContext(ParserInstance parserInstance) {
+			super(parserInstance);
+		}
+
 	}
 
 }

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

@@ -33,7 +33,14 @@ public abstract class Statement extends TriggerItem implements SyntaxElement {
 			Section.SectionContext sectionContext = ParserInstance.get().getData(Section.SectionContext.class);
 			EffFunctionCall functionCall;
 			if (node != null) {
-				functionCall = sectionContext.modify(node, items, () -> EffFunctionCall.parse(input));
+				functionCall = sectionContext.modify(node, items, () -> {
+					EffFunctionCall parsed = EffFunctionCall.parse(input);
+					if (parsed != null && !sectionContext.claimed()) {
+						Skript.error("The line '" + input + "' is a valid function call but cannot function as a section (:) because there is no parameter to manage it.");
+						return null;
+					}
+					return parsed;
+				});
 			} else {
 				functionCall = EffFunctionCall.parse(input);
 			}
@@ -46,7 +53,7 @@ public abstract class Statement extends TriggerItem implements SyntaxElement {
 			}
 			log.clear();
 
-			EffectSection section = EffectSection.parse(input, null, null, items);
+			EffectSection section = EffectSection.parse(input, null, node, false, items);
 			if (section != null) {
 				log.printLog();
 				return new EffectSectionEffect(section);

src/main/java/org/skriptlang/skript/lang/arithmetic/OperationInfo.java

@@ -1,6 +1,8 @@
 package org.skriptlang.skript.lang.arithmetic;
 
 import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.skriptlang.skript.lang.converter.Converters;
 
@@ -18,6 +20,22 @@
  */
 public record OperationInfo<L, R, T>(Class<L> left, Class<R> right, Class<T> returnType, Operation<L, R, T> operation) {
 
+	public OperationInfo(
+		@NotNull Class<L> left,
+		@NotNull Class<R> right,
+		@NotNull Class<T> returnType,
+		@NotNull Operation<L, R, T> operation
+	) {
+		Preconditions.checkNotNull(left, "Cannot do arithmetic with nothing and something! (left is null)");
+		Preconditions.checkNotNull(right, "Cannot do arithmetic with something and nothing! (right is null)");
+		Preconditions.checkNotNull(returnType, "Cannot have nothing as the result of arithmetic! (returnType is null)");
+		Preconditions.checkNotNull(operation, "Cannot do arithmetic with a null operation!");
+		this.left = left;
+		this.right = right;
+		this.returnType = returnType;
+		this.operation = operation;
+	}
+
 	@Deprecated(since = "2.13", forRemoval = true)
 	public Class<L> getLeft() {
 		return left;

src/main/java/org/skriptlang/skript/lang/comparator/ComparatorInfo.java

@@ -1,5 +1,8 @@
 package org.skriptlang.skript.lang.comparator;
 
+import com.google.common.base.Preconditions;
+import org.jetbrains.annotations.NotNull;
+
 /**
  * Holds information about a Comparator.
  *
@@ -12,7 +15,14 @@ public final class ComparatorInfo<T1, T2> {
 	private final Class<T2> secondType;
 	private final Comparator<T1, T2> comparator;
 
-	ComparatorInfo(Class<T1> firstType, Class<T2> secondType, Comparator<T1, T2> comparator) {
+	ComparatorInfo(
+		@NotNull Class<T1> firstType,
+		@NotNull Class<T2> secondType,
+		@NotNull Comparator<T1, T2> comparator
+	) {
+		Preconditions.checkNotNull(firstType, "Cannot create a comparison between nothing and something! (firstType is null)");
+		Preconditions.checkNotNull(secondType, "Cannot create a comparison between something and nothing! (secondType is null)");
+		Preconditions.checkNotNull(comparator, "Cannot create a comparison with a null comparator!");
 		this.firstType = firstType;
 		this.secondType = secondType;
 		this.comparator = comparator;

src/main/java/org/skriptlang/skript/lang/converter/ConverterInfo.java

@@ -1,5 +1,8 @@
 package org.skriptlang.skript.lang.converter;
 
+import com.google.common.base.Preconditions;
+import org.jetbrains.annotations.NotNull;
+
 /**
  * Holds information about a {@link Converter}.
  *
@@ -13,7 +16,15 @@ public final class ConverterInfo<F, T> {
 	private final Converter<F, T> converter;
 	private final int flags;
 
-	public ConverterInfo(Class<F> from, Class<T> to, Converter<F, T> converter, int flags) {
+	public ConverterInfo(
+		@NotNull Class<F> from,
+		@NotNull Class<T> to,
+		@NotNull Converter<F, T> converter,
+		int flags
+	) {
+		Preconditions.checkNotNull(from, "Cannot convert from nothing to something! (from is null)");
+		Preconditions.checkNotNull(to, "Cannot convert from something to nothing! (to is null)");
+		Preconditions.checkNotNull(converter, "Cannot convert using a null converter!");
 		this.from = from;
 		this.to = to;
 		this.converter = converter;

src/test/skript/tests/regressions/8199-parse exprsecs in function args.sk

@@ -4,3 +4,9 @@ local function f(x: worldborder):
 test "load expr secs in functions":
     f(a worldborder):
         set worldborder warning time to 20 ticks
+
+    # ensure it fails for unclaimed sections
+    parse:
+        f({_null}):
+            stop
+    assert first element of last parse logs contains "is a valid function call but cannot function as a section" with "failed to correctly error for unclaimed section"