Switch sections (experimental feature).

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

@@ -60,8 +60,10 @@
 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.concurrent.BlockingQueue;
@@ -490,17 +492,17 @@ private static CompletableFuture<ScriptInfo> loadScripts(List<Config> configs, O
 
 		ScriptInfo scriptInfo = new ScriptInfo();
 
-		List<NonNullPair<Script, List<Structure>>> scripts = new ArrayList<>();
+		List<LoadingScriptInfo> scripts = new ArrayList<>();
 
 		List<CompletableFuture<Void>> scriptInfoFutures = new ArrayList<>();
 		for (Config config : configs) {
 			if (config == null)
 				throw new NullPointerException();
 
 			CompletableFuture<Void> future = makeFuture(() -> {
-				NonNullPair<Script, List<Structure>> pair = loadScript(config);
-				scripts.add(pair);
-				scriptInfo.add(new ScriptInfo(1, pair.getSecond().size()));
+				LoadingScriptInfo info = loadScript(config);
+				scripts.add(info);
+				scriptInfo.add(new ScriptInfo(1, info.structures.size()));
 				return null;
 			}, openCloseable);
 
@@ -518,31 +520,32 @@ private static CompletableFuture<ScriptInfo> loadScripts(List<Config> configs, O
 
 					// build sorted list
 					// this nest of pairs is terrible, but we need to keep the reference to the modifiable structures list
-					List<NonNullPair<NonNullPair<Script, List<Structure>>, Structure>> pairs = scripts.stream()
-							.flatMap(pair -> { // Flatten each entry down to a stream of Script-Structure pairs
-								return pair.getSecond().stream()
-										.map(structure -> new NonNullPair<>(pair, structure));
+					List<NonNullPair<LoadingScriptInfo, Structure>> pairs = scripts.stream()
+							.flatMap(info -> { // Flatten each entry down to a stream of Script-Structure pairs
+								return info.structures.stream()
+										.map(structure -> new NonNullPair<>(info, structure));
 							})
 							.sorted(Comparator.comparing(pair -> pair.getSecond().getPriority()))
 							.collect(Collectors.toCollection(ArrayList::new));
 
 					// pre-loading
 					pairs.removeIf(pair -> {
+						LoadingScriptInfo loadingInfo = pair.getFirst();
 						Structure structure = pair.getSecond();
 
-						parser.setActive(pair.getFirst().getFirst());
+						parser.setActive(loadingInfo.script);
 						parser.setCurrentStructure(structure);
-						parser.setNode(structure.getEntryContainer().getSource());
+						parser.setNode(loadingInfo.nodeMap.get(structure));
 
 						try {
 							if (!structure.preLoad()) {
-								pair.getFirst().getSecond().remove(structure);
+								loadingInfo.structures.remove(structure);
 								return true;
 							}
 						} catch (Exception e) {
 							//noinspection ThrowableNotThrown
 							Skript.exception(e, "An error occurred while trying to preLoad a Structure.");
-							pair.getFirst().getSecond().remove(structure);
+							loadingInfo.structures.remove(structure);
 							return true;
 						}
 						return false;
@@ -556,21 +559,22 @@ private static CompletableFuture<ScriptInfo> loadScripts(List<Config> configs, O
 
 					// loading
 					pairs.removeIf(pair -> {
+						LoadingScriptInfo loadingInfo = pair.getFirst();
 						Structure structure = pair.getSecond();
 
-						parser.setActive(pair.getFirst().getFirst());
+						parser.setActive(loadingInfo.script);
 						parser.setCurrentStructure(structure);
-						parser.setNode(structure.getEntryContainer().getSource());
+						parser.setNode(loadingInfo.nodeMap.get(structure));
 
 						try {
 							if (!structure.load()) {
-								pair.getFirst().getSecond().remove(structure);
+								loadingInfo.structures.remove(structure);
 								return true;
 							}
 						} catch (Exception e) {
 							//noinspection ThrowableNotThrown
 							Skript.exception(e, "An error occurred while trying to load a Structure.");
-							pair.getFirst().getSecond().remove(structure);
+							loadingInfo.structures.remove(structure);
 							return true;
 						}
 						return false;
@@ -579,21 +583,22 @@ private static CompletableFuture<ScriptInfo> loadScripts(List<Config> configs, O
 
 					// post-loading
 					pairs.removeIf(pair -> {
+						LoadingScriptInfo loadingInfo = pair.getFirst();
 						Structure structure = pair.getSecond();
 
-						parser.setActive(pair.getFirst().getFirst());
+						parser.setActive(loadingInfo.script);
 						parser.setCurrentStructure(structure);
-						parser.setNode(structure.getEntryContainer().getSource());
+						parser.setNode(loadingInfo.nodeMap.get(structure));
 
 						try {
 							if (!structure.postLoad()) {
-								pair.getFirst().getSecond().remove(structure);
+								loadingInfo.structures.remove(structure);
 								return true;
 							}
 						} catch (Exception e) {
 							//noinspection ThrowableNotThrown
 							Skript.exception(e, "An error occurred while trying to postLoad a Structure.");
-							pair.getFirst().getSecond().remove(structure);
+							loadingInfo.structures.remove(structure);
 							return true;
 						}
 						return false;
@@ -612,17 +617,34 @@ private static CompletableFuture<ScriptInfo> loadScripts(List<Config> configs, O
 			});
 	}
 
+	private static class LoadingScriptInfo {
+
+		public final Script script;
+
+		public final List<Structure> structures;
+
+		public final Map<Structure, Node> nodeMap;
+
+		public LoadingScriptInfo(Script script, List<Structure> structures, Map<Structure, Node> nodeMap) {
+			this.script = script;
+			this.structures = structures;
+			this.nodeMap = nodeMap;
+		}
+
+	}
+
 	/**
 	 * Creates a script and loads the provided config into it.
 	 * @param config The config to load into a script.
 	 * @return A pair containing the script that was loaded and a modifiable version of the structures list.
 	 */
 	// Whenever you call this method, make sure to also call PreScriptLoadEvent
-	private static NonNullPair<Script, List<Structure>> loadScript(Config config) {
+	private static LoadingScriptInfo loadScript(Config config) {
 		if (config.getFile() == null)
 			throw new IllegalArgumentException("A config must have a file to be loaded.");
 
 		ParserInstance parser = getParser();
+		Map<Structure, Node> nodeMap = new HashMap<>();
 		List<Structure> structures = new ArrayList<>();
 		Script script = new Script(config, structures);
 		parser.setActive(script);
@@ -632,31 +654,31 @@ private static NonNullPair<Script, List<Structure>> loadScript(Config config) {
 				SkriptConfig.configs.add(config);
 
 			try (CountingLogHandler ignored = new CountingLogHandler(SkriptLogger.SEVERE).start()) {
-				for (Node cnode : config.getMainNode()) {
-					if (!(cnode instanceof SectionNode)) {
-						Skript.error("invalid line - all code has to be put into triggers");
+				for (Node node : config.getMainNode()) {
+					if (!(node instanceof SimpleNode) && !(node instanceof SectionNode)) {
+						// unlikely to occur, but just in case
+						Skript.error("could not interpret line as a structure");
 						continue;
 					}
 
-					SectionNode node = ((SectionNode) cnode);
 					String line = node.getKey();
 					if (line == null)
 						continue;
+					line = replaceOptions(line); // replace options here before validation
 
 					if (!SkriptParser.validateLine(line))
 						continue;
 
 					if (Skript.logVeryHigh() && !Skript.debug())
 						Skript.info("loading trigger '" + line + "'");
 
-					line = replaceOptions(line);
-
 					Structure structure = Structure.parse(line, node, "Can't understand this structure: " + line);
 
 					if (structure == null)
 						continue;
 
 					structures.add(structure);
+					nodeMap.put(structure, node);
 				}
 
 				if (Skript.logHigh()) {
@@ -694,8 +716,8 @@ private static NonNullPair<Script, List<Structure>> loadScript(Config config) {
 				Skript.exception(e);
 			}
 		}
-		
-		return new NonNullPair<>(script, structures);
+
+		return new LoadingScriptInfo(script, structures, nodeMap);
 	}
 
 	/*

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

@@ -83,7 +83,6 @@
 import ch.njol.util.Kleenean;
 import ch.njol.util.NullableChecker;
 import ch.njol.util.StringUtils;
-import ch.njol.util.coll.CollectionUtils;
 import ch.njol.util.coll.iterator.CheckedIterator;
 import ch.njol.util.coll.iterator.EnumerationIterable;
 import com.google.common.collect.Lists;
@@ -108,6 +107,7 @@
 import org.bukkit.plugin.PluginDescriptionFile;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.eclipse.jdt.annotation.Nullable;
+import org.jetbrains.annotations.UnknownNullability;
 import org.junit.After;
 import org.junit.runner.JUnitCore;
 import org.junit.runner.Result;
@@ -116,6 +116,9 @@
 import org.skriptlang.skript.lang.converter.Converter;
 import org.skriptlang.skript.lang.converter.Converters;
 import org.skriptlang.skript.lang.entry.EntryValidator;
+import org.skriptlang.skript.lang.experiment.ExperimentManager;
+import org.skriptlang.skript.lang.experiment.Feature;
+import org.skriptlang.skript.lang.script.Annotation;
 import org.skriptlang.skript.lang.script.Script;
 import org.skriptlang.skript.lang.structure.Structure;
 import org.skriptlang.skript.lang.structure.StructureInfo;
@@ -230,6 +233,7 @@ public static void updateMinecraftVersion() {
 
 	@Nullable
 	private static Version version = null;
+	private static @UnknownNullability ExperimentManager experimentManager;
 
 	public static Version getVersion() {
 		final Version v = version;
@@ -362,6 +366,13 @@ public static void disableHookRegistration(Class<? extends Hook<?>>... hooks) {
 	 */
 	private File scriptsFolder;
 
+	/**
+	 * @return The manager for experimental, optional features.
+	 */
+	public static ExperimentManager experiments() {
+		return experimentManager;
+	}
+
 	/**
 	 * @return The folder containing all Scripts.
 	 */
@@ -392,6 +403,8 @@ public void onEnable() {
 		} catch (Exception e) {
 			Skript.exception(e, "Update checker could not be initialized.");
 		}
+		experimentManager = new ExperimentManager(this);
+		Feature.registerAll(getAddonInstance(), experimentManager);
 
 		if (!getDataFolder().isDirectory())
 			getDataFolder().mkdirs();
@@ -1197,6 +1210,7 @@ public void onDisable() {
 		if (disabled)
 			return;
 		disabled = true;
+		this.experimentManager = null;
 
 		if (!partDisabled) {
 			beforeDisable();
@@ -1515,6 +1529,13 @@ public static <E extends Structure> void registerStructure(Class<E> c, String...
 		structures.add(structureInfo);
 	}
 
+	public static <E extends Structure> void registerSimpleStructure(Class<E> c, String... patterns) {
+		checkAcceptRegistrations();
+		String originClassPath = Thread.currentThread().getStackTrace()[2].getClassName();
+		StructureInfo<E> structureInfo = new StructureInfo<>(patterns, c, originClassPath, true);
+		structures.add(structureInfo);
+	}
+
 	public static <E extends Structure> void registerStructure(Class<E> c, EntryValidator entryValidator, String... patterns) {
 		checkAcceptRegistrations();
 		String originClassPath = Thread.currentThread().getStackTrace()[2].getClassName();
@@ -1605,16 +1626,18 @@ public static void info(final String info) {
 	 */
 	@SuppressWarnings("null")
 	public static void warning(final String warning) {
-		SkriptLogger.log(Level.WARNING, warning);
+		if (!Annotation.isAnnotationPresent("suppress warnings"))
+			SkriptLogger.log(Level.WARNING, warning);
 	}
 
 	/**
 	 * @see SkriptLogger#log(Level, String)
 	 */
 	@SuppressWarnings("null")
 	public static void error(final @Nullable String error) {
-		if (error != null)
-			SkriptLogger.log(Level.SEVERE, error);
+		if (error == null || Annotation.isAnnotationPresent("suppress errors"))
+			return;
+		SkriptLogger.log(Level.SEVERE, error);
 	}
 
 	/**
@@ -1625,6 +1648,8 @@ public static void error(final @Nullable String error) {
 	 * @param quality
 	 */
 	public static void error(final String error, final ErrorQuality quality) {
+		if (Annotation.isAnnotationPresent("suppress errors"))
+			return;
 		SkriptLogger.log(new LogEntry(SkriptLogger.SEVERE, quality, error));
 	}