Local Variable Type Hints (SkriptLang#7892)

Author: APickledWalrus

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

@@ -5,6 +5,7 @@
 import ch.njol.skript.config.SectionNode;
 import ch.njol.skript.config.SimpleNode;
 import ch.njol.skript.events.bukkit.PreScriptLoadEvent;
+import ch.njol.skript.lang.ExecutionIntent;
 import ch.njol.skript.lang.Section;
 import ch.njol.skript.lang.SkriptParser;
 import ch.njol.skript.lang.Statement;
@@ -20,7 +21,7 @@
 import ch.njol.skript.util.SkriptColor;
 import ch.njol.skript.util.Task;
 import ch.njol.skript.util.Timespan;
-import ch.njol.skript.variables.TypeHints;
+import ch.njol.skript.variables.HintManager;
 import ch.njol.util.NonNullPair;
 import ch.njol.util.OpenCloseable;
 import ch.njol.util.StringUtils;
@@ -951,6 +952,14 @@ public static ArrayList<TriggerItem> loadItems(SectionNode node) {
 
 		ArrayList<TriggerItem> items = new ArrayList<>();
 
+		// Begin local variable type hints
+		parser.getHintManager().enterScope(true);
+		// Track if the scope has been frozen
+		// This is the case when a statement that stops further execution is encountered
+		// Further statements would not run, meaning the hints from them are inaccurate
+		// When true, before exiting the scope, its hints are cleared to avoid passing them up
+		boolean freezeScope = false;
+
 		boolean executionStops = false;
 		for (Node subNode : node) {
 			parser.setNode(subNode);
@@ -983,11 +992,18 @@ public static ArrayList<TriggerItem> loadItems(SectionNode node) {
 
 				items.add(item);
 			} else if (subNode instanceof SectionNode subSection) {
-				TypeHints.enterScope(); // Begin conditional type hints
 
 				RetainingLogHandler handler = SkriptLogger.startRetainingLog();
 				find_section:
 				try {
+					// enter capturing scope
+					// it is possible that the line may successfully parse and initialize (via init), but some other issue
+					// prevents it from being able to load. for example:
+					// - a statement with a section that has no expression to claim the section
+					// - a statement with a section that has multiple expressions attempting to claim the section
+					// thus, hints may be added, but we do not want to save them as the line is invalid
+					parser.getHintManager().enterScope(false);
+
 					item = Section.parse(expr, "Can't understand this section: " + expr, subSection, items);
 					if (item != null)
 						break find_section;
@@ -1014,6 +1030,13 @@ public static ArrayList<TriggerItem> loadItems(SectionNode node) {
 					}
 					continue;
 				} finally {
+					// exit hint scope (see above)
+					HintManager hintManager = parser.getHintManager();
+					if (item == null) { // unsuccessful, wipe out hints
+						hintManager.clearScope(0, false);
+					}
+					hintManager.exitScope();
+
 					RetainingLogHandler afterParse = handler.backup();
 					handler.clear();
 					handler.printLog();
@@ -1023,9 +1046,6 @@ public static ArrayList<TriggerItem> loadItems(SectionNode node) {
 				}
 
 				items.add(item);
-
-				// Destroy these conditional type hints
-				TypeHints.exitScope();
 			} else {
 				continue;
 			}
@@ -1037,7 +1057,24 @@ public static ArrayList<TriggerItem> loadItems(SectionNode node) {
 				Skript.warning("Unreachable code. The previous statement stops further execution.");
 			}
 			executionStops = item.executionIntent() != null;
+
+			if (executionStops && !freezeScope) {
+				freezeScope = true;
+				// Execution might stop for some sections but not all
+				// We want to pass hints up to the scope that execution resumes in
+				if (item.executionIntent() instanceof ExecutionIntent.StopSections intent) {
+					parser.getHintManager().mergeScope(0, intent.levels(), true);
+				}
+			}
+		}
+
+		// If the scope was frozen, then we need to clear it to prevent passing up inaccurate hints
+		// They will have already been copied as necessary
+		if (freezeScope) {
+			parser.getHintManager().clearScope(0, false);
 		}
+		// Destroy local variable type hints for this section
+		parser.getHintManager().exitScope();
 
 		for (int i = 0; i < items.size() - 1; i++)
 			items.get(i).setNext(items.get(i + 1));

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

@@ -1264,7 +1264,6 @@ public void onDisable() {
 		if (disabled)
 			return;
 		disabled = true;
-		this.experimentRegistry = null;
 
 		if (!partDisabled) {
 			beforeDisable();
@@ -1279,6 +1278,8 @@ public void onDisable() {
 				Skript.exception(e, "An error occurred while shutting down.", "This might or might not cause any issues.");
 			}
 		}
+
+		this.experimentRegistry = null;
 	}
 
 	// ================ CONSTANTS, OPTIONS & OTHER ================

src/main/java/ch/njol/skript/command/Argument.java

@@ -130,6 +130,10 @@ public void set(final ScriptCommandEvent e, final Object[] o) {
 	public T[] getCurrent(final Event e) {
 		return current.get(e);
 	}
+
+	public @Nullable String getName() {
+		return name;
+	}
 
 	public Class<T> getType() {
 		return type.getC();

src/main/java/ch/njol/skript/command/ScriptCommand.java

@@ -8,7 +8,9 @@
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.SkriptParser;
 import ch.njol.skript.lang.Trigger;
+import ch.njol.skript.lang.Variable;
 import ch.njol.skript.lang.VariableString;
+import ch.njol.skript.lang.parser.ParserInstance;
 import ch.njol.skript.lang.util.SimpleEvent;
 import ch.njol.skript.lang.util.SimpleLiteral;
 import ch.njol.skript.localization.Language;
@@ -23,6 +25,7 @@
 import ch.njol.skript.util.Utils;
 import ch.njol.skript.util.chat.BungeeConverter;
 import ch.njol.skript.util.chat.MessageComponent;
+import ch.njol.skript.variables.HintManager;
 import ch.njol.skript.variables.Variables;
 import ch.njol.util.StringUtils;
 import com.google.common.base.Preconditions;
@@ -204,8 +207,24 @@ public ScriptCommand(
 		this.pattern = pattern;
 		this.arguments = arguments;
 
-		trigger = new Trigger(script, "command /" + name, new SimpleEvent(), ScriptLoader.loadItems(node));
-		trigger.setLineNumber(node.getLine());
+		HintManager hintManager = ParserInstance.get().getHintManager();
+		try {
+			hintManager.enterScope(false);
+			for (Argument<?> argument : arguments) {
+				String hintName = argument.getName();
+				if (hintName == null) {
+					continue;
+				}
+				if (!argument.isSingle()) {
+					hintName += Variable.SEPARATOR + "*";
+				}
+				hintManager.set(hintName, argument.getType());
+			}
+			trigger = new Trigger(script, "command /" + name, new SimpleEvent(), ScriptLoader.loadItems(node));
+			trigger.setLineNumber(node.getLine());
+		} finally {
+			hintManager.exitScope();
+		}
 
 		bukkitCommand = setupBukkitCommand();
 	}

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

@@ -15,6 +15,7 @@
 import ch.njol.skript.lang.SyntaxStringBuilder;
 import ch.njol.skript.lang.Variable;
 import ch.njol.skript.util.LiteralUtils;
+import ch.njol.skript.variables.HintManager;
 import org.skriptlang.skript.lang.script.ScriptWarning;
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.Nullable;
@@ -180,6 +181,12 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 			flatAcceptedTypes[i] = type;
 		}
 
+		// Hint handling for deleting
+		if (changed instanceof Variable<?> variable && mode == ChangeMode.DELETE && HintManager.canUseHints(variable)) {
+			// Remove type hints in this scope only for a deleted variable
+			getParser().getHintManager().delete(variable);
+		}
+
 		if (changer == null) { // Safe to reset/delete
 			return true;
 		}
@@ -271,13 +278,24 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 			}
 
 			// Print warning if attempting to save a non-serializable type in a global variable
-			if (!variable.isLocal() && (mode == ChangeMode.SET || (variable.isList() && mode == ChangeMode.ADD))) {
-				ClassInfo<?> changerInfo = Classes.getSuperClassInfo(changer.getReturnType());
-				if (changerInfo.getC() != Object.class && changerInfo.getSerializer() == null && changerInfo.getSerializeAs() == null
-					&& !SkriptConfig.disableObjectCannotBeSavedWarnings.value()
-					&& getParser().isActive() && !getParser().getCurrentScript().suppressesWarning(ScriptWarning.VARIABLE_SAVE)) {
-					Skript.warning(changerInfo.getName().withIndefiniteArticle() + " cannot be saved. That is, the contents of the variable "
-						+ changed.toString(null, Skript.debug()) + " will be lost when the server stops.");
+			if (mode == ChangeMode.SET || (variable.isList() && mode == ChangeMode.ADD)) {
+				if (HintManager.canUseHints(variable)) { // Hint handling
+					HintManager hintManager = getParser().getHintManager();
+					Class<?>[] hints = changer.possibleReturnTypes();
+					if (mode == ChangeMode.SET) { // Override existing hints in scope
+						hintManager.set(variable, hints);
+					} else {
+						hintManager.add(variable, hints);
+					}
+				}
+				if (!variable.isLocal()) {
+					ClassInfo<?> changerInfo = Classes.getSuperClassInfo(changer.getReturnType());
+					if (changerInfo.getC() != Object.class && changerInfo.getSerializer() == null && changerInfo.getSerializeAs() == null
+						&& !SkriptConfig.disableObjectCannotBeSavedWarnings.value()
+						&& getParser().isActive() && !getParser().getCurrentScript().suppressesWarning(ScriptWarning.VARIABLE_SAVE)) {
+						Skript.warning(changerInfo.getName().withIndefiniteArticle() + " cannot be saved. That is, the contents of the variable "
+							+ changed.toString(null, Skript.debug()) + " will be lost when the server stops.");
+					}
 				}
 			}
 		}

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

@@ -13,6 +13,7 @@
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.lang.Variable;
 import ch.njol.skript.registrations.Classes;
+import ch.njol.skript.variables.HintManager;
 import ch.njol.skript.variables.Variables;
 import ch.njol.util.Kleenean;
 import org.bukkit.event.Event;
@@ -64,6 +65,16 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 				return false;
 			}
 		}
+
+		// set type hints for destination(s) if applicable
+		Class<?>[] sourceHints = source.possibleReturnTypes();
+		HintManager hintManager = getParser().getHintManager();
+		for (Variable<?> destination : destinations) {
+			if (HintManager.canUseHints(destination)) {
+				hintManager.set(destination, sourceHints);
+			}
+		}
+
 		return true;
 	}
 

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

@@ -1,5 +1,6 @@
 package ch.njol.skript.effects;
 
+import ch.njol.skript.lang.ExecutionIntent;
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.Nullable;
 
@@ -43,7 +44,19 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 			return false;
 		}
 		condition = Condition.parse(cond, "Can't understand this condition: " + cond);
-		return effect != null && condition != null;
+
+		if (effect == null || condition == null) {
+			return false;
+		}
+
+		// handle special hint cases
+		// if this statement could result in execution stopping, we want to pass up hints
+		if (effect.executionIntent() instanceof ExecutionIntent.StopSections intent) {
+			// copy up current hints
+			getParser().getHintManager().mergeScope(0, intent.levels(), true);
+		}
+
+		return true;
 	}
 
 	@Override

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

@@ -86,6 +86,8 @@ public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelaye
 		List<TriggerSection> innerSections = parser.getSectionsUntil((TriggerSection) handler);
 		innerSections.add(0, (TriggerSection) handler);
 		breakLevels = innerSections.size();
+		if (parser.getCurrentSections().size() < breakLevels)
+			breakLevels = -1;
 		sectionsToExit = innerSections.stream()
 			.filter(SectionExitHandler.class::isInstance)
 			.map(SectionExitHandler.class::cast)
@@ -112,6 +114,8 @@ protected void execute(Event event) {
 
 	@Override
 	public ExecutionIntent executionIntent() {
+		if (breakLevels == -1)
+			return ExecutionIntent.stopTrigger();
 		return ExecutionIntent.stopSections(breakLevels);
 	}
 

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

@@ -0,0 +1,62 @@
+package ch.njol.skript.effects;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Example;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
+import ch.njol.skript.lang.Effect;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.registrations.Feature;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.lang.experiment.ExperimentData;
+import org.skriptlang.skript.lang.experiment.SimpleExperimentalSyntax;
+
+@Name("Suppress Type Hints (Experimental)")
+@Description({
+	"An effect to suppress local variable type hint errors for the syntax lines that follow this effect.",
+	"NOTE: Suppressing type hints also prevents syntax from providing new type hints." +
+		" For example, with type hints suppressed, 'set {_x} to true' would not provide 'boolean' as a type hint for '{_x}'"
+})
+@Example("""
+	start suppressing local variable type hints
+	# potentially unsafe code goes here
+	stop suppressing local variable type hints
+""")
+@Since("INSERT VERSION")
+public class EffSuppressTypeHints extends Effect implements SimpleExperimentalSyntax {
+
+	private static final ExperimentData EXPERIMENT_DATA = ExperimentData.createSingularData(Feature.TYPE_HINTS);
+
+	static {
+		Skript.registerEffect(EffSuppressTypeHints.class,
+				"[stop:un]suppress [local variable] type hints",
+				"(start|:stop) suppressing [local variable] type hints");
+	}
+
+	private boolean stop;
+
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		stop = parseResult.hasTag("stop");
+		getParser().getHintManager().setActive(stop);
+		return true;
+	}
+
+	@Override
+	protected void execute(Event event) { }
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return (stop ? "stop" : "start") + " suppressing type hints";
+	}
+
+	@Override
+	public ExperimentData getExperimentData() {
+		return EXPERIMENT_DATA;
+	}
+
+}