From bd1d37023f2f8f2b054c3a9b301ae0404706de2b Mon Sep 17 00:00:00 2001 From: Patrick Miller Date: Wed, 12 Aug 2026 13:33:03 -0400 Subject: [PATCH 1/3] Migrate suppression syntaxes --- .../skript/common/CommonModule.java | 3 ++ .../effects/EffSuppressTypeHints.java | 31 ++++++++++--------- .../effects/EffSuppressWarnings.java | 16 +++++++--- 3 files changed, 30 insertions(+), 20 deletions(-) rename src/main/java/{ch/njol/skript => org/skriptlang/skript/common/elements}/effects/EffSuppressTypeHints.java (56%) rename src/main/java/{ch/njol/skript => org/skriptlang/skript/common/elements}/effects/EffSuppressWarnings.java (76%) diff --git a/src/main/java/org/skriptlang/skript/common/CommonModule.java b/src/main/java/org/skriptlang/skript/common/CommonModule.java index 762ec04c158..fed30521d6c 100644 --- a/src/main/java/org/skriptlang/skript/common/CommonModule.java +++ b/src/main/java/org/skriptlang/skript/common/CommonModule.java @@ -4,6 +4,7 @@ import org.skriptlang.skript.addon.AddonModule; import org.skriptlang.skript.addon.HierarchicalAddonModule; import org.skriptlang.skript.addon.SkriptAddon; +import org.skriptlang.skript.common.elements.effects.*; import org.skriptlang.skript.common.elements.expressions.*; import org.skriptlang.skript.common.properties.PropertiesModule; import org.skriptlang.skript.common.types.*; @@ -30,6 +31,8 @@ protected void initSelf(SkriptAddon addon) { @Override protected void loadSelf(SkriptAddon addon) { register(addon, + EffSuppressTypeHints::register, + EffSuppressWarnings::register, ExprColorFromHexCode::register, ExprHexCode::register, ExprRecursiveSize::register, diff --git a/src/main/java/ch/njol/skript/effects/EffSuppressTypeHints.java b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressTypeHints.java similarity index 56% rename from src/main/java/ch/njol/skript/effects/EffSuppressTypeHints.java rename to src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressTypeHints.java index db7c550d283..1b72debe228 100644 --- a/src/main/java/ch/njol/skript/effects/EffSuppressTypeHints.java +++ b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressTypeHints.java @@ -1,6 +1,5 @@ -package ch.njol.skript.effects; +package org.skriptlang.skript.common.elements.effects; -import ch.njol.skript.Skript; import ch.njol.skript.doc.Description; import ch.njol.skript.doc.Example; import ch.njol.skript.doc.Name; @@ -14,13 +13,15 @@ import org.jetbrains.annotations.Nullable; import org.skriptlang.skript.lang.experiment.ExperimentData; import org.skriptlang.skript.lang.experiment.SimpleExperimentalSyntax; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; @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}'" -}) +@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 @@ -31,18 +32,18 @@ public class EffSuppressTypeHints extends Effect implements SimpleExperimentalSy 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"); + public static void register(SyntaxRegistry syntaxRegistry) { + syntaxRegistry.register(SyntaxRegistry.EFFECT, SyntaxInfo.simple(EffSuppressTypeHints.class, EffSuppressTypeHints::new, + "[stop:un]suppress [local variable] type hints", + "(start|:stop) suppressing [local variable] type hints")); } - private boolean stop; + private boolean stopSuppression; @Override public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { - stop = parseResult.hasTag("stop"); - getParser().getHintManager().setActive(stop); + stopSuppression = parseResult.hasTag("stop"); + getParser().getHintManager().setActive(stopSuppression); return true; } @@ -51,7 +52,7 @@ protected void execute(Event event) { } @Override public String toString(@Nullable Event event, boolean debug) { - return (stop ? "stop" : "start") + " suppressing type hints"; + return (stopSuppression ? "stop" : "start") + " suppressing type hints"; } @Override diff --git a/src/main/java/ch/njol/skript/effects/EffSuppressWarnings.java b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java similarity index 76% rename from src/main/java/ch/njol/skript/effects/EffSuppressWarnings.java rename to src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java index 9a3f9897471..7fd375cd711 100644 --- a/src/main/java/ch/njol/skript/effects/EffSuppressWarnings.java +++ b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java @@ -1,4 +1,4 @@ -package ch.njol.skript.effects; +package org.skriptlang.skript.common.elements.effects; import ch.njol.skript.Skript; import ch.njol.skript.doc.Description; @@ -13,6 +13,8 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.UnknownNullability; import org.skriptlang.skript.lang.script.ScriptWarning; +import org.skriptlang.skript.registration.SyntaxInfo; +import org.skriptlang.skript.registration.SyntaxRegistry; @Name("Locally Suppress Warning") @Description("Suppresses target warnings from the current script.") @@ -21,15 +23,19 @@ @Since("2.3") public class EffSuppressWarnings extends Effect { - static { + public static void register(SyntaxRegistry syntaxRegistry) { StringBuilder warnings = new StringBuilder(); ScriptWarning[] values = ScriptWarning.values(); for (int i = 0; i < values.length; i++) { - if (i != 0) + if (i != 0) { warnings.append('|'); - warnings.append(values[i].ordinal()).append(':').append(values[i].getPattern()); + } + warnings.append(values[i].ordinal()) + .append(':') + .append(values[i].getPattern()); } - Skript.registerEffect(EffSuppressWarnings.class, "[local[ly]] suppress [the] (" + warnings + ") warning[s]"); + syntaxRegistry.register(SyntaxRegistry.EFFECT, SyntaxInfo.simple(EffSuppressWarnings.class, EffSuppressWarnings::new, + "[local[ly]] suppress [the] (" + warnings + ") warning[s]")); } private @UnknownNullability ScriptWarning warning; From 441c53f1e4b915de1533adf9401ce9d1d73e045d Mon Sep 17 00:00:00 2001 From: Patrick Miller Date: Wed, 12 Aug 2026 13:47:07 -0400 Subject: [PATCH 2/3] Add support for unsuppressing warnings --- .../elements/effects/EffSuppressWarnings.java | 12 ++++++++---- .../skript/tests/common/EffSuppressWarnings.sk | 18 ++++++++++++++++++ 2 files changed, 26 insertions(+), 4 deletions(-) create mode 100644 src/test/skript/tests/common/EffSuppressWarnings.sk diff --git a/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java index 7fd375cd711..6fa25cb3c40 100644 --- a/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java +++ b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java @@ -11,7 +11,6 @@ import ch.njol.util.Kleenean; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; -import org.jetbrains.annotations.UnknownNullability; import org.skriptlang.skript.lang.script.ScriptWarning; import org.skriptlang.skript.registration.SyntaxInfo; import org.skriptlang.skript.registration.SyntaxRegistry; @@ -35,10 +34,12 @@ public static void register(SyntaxRegistry syntaxRegistry) { .append(values[i].getPattern()); } syntaxRegistry.register(SyntaxRegistry.EFFECT, SyntaxInfo.simple(EffSuppressWarnings.class, EffSuppressWarnings::new, - "[local[ly]] suppress [the] (" + warnings + ") warning[s]")); + "[local[ly]] [stop:un]suppress [the] (" + warnings + ") warning[s]", + "[start|:stop] [local[ly]] suppressing [the] (" + warnings + ") warning[s]")); } - private @UnknownNullability ScriptWarning warning; + private ScriptWarning warning; + private boolean stop; @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { @@ -48,8 +49,11 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye } warning = ScriptWarning.values()[parseResult.mark]; + stop = parseResult.hasTag("stop"); if (warning.isDeprecated()) { Skript.warning(warning.getDeprecationMessage()); + } else if (stop) { + getParser().getCurrentScript().allowWarning(warning); } else { getParser().getCurrentScript().suppressWarning(warning); } @@ -61,7 +65,7 @@ protected void execute(Event event) { } @Override public String toString(@Nullable Event event, boolean debug) { - return "suppress " + warning.getWarningName() + " warnings"; + return (stop ? "un" : "") + "suppress " + warning.getWarningName() + " warnings"; } } diff --git a/src/test/skript/tests/common/EffSuppressWarnings.sk b/src/test/skript/tests/common/EffSuppressWarnings.sk new file mode 100644 index 00000000000..5058ba94af0 --- /dev/null +++ b/src/test/skript/tests/common/EffSuppressWarnings.sk @@ -0,0 +1,18 @@ +test "EffSuppressWarnings": + + parse: + stop + stop + assert last parse logs is "Unreachable code. The previous statement stops further execution." + + suppress unreachable code warnings + parse: + stop + stop + assert last parse logs is not set + unsuppress unreachable code warnings + + parse: + stop + stop + assert last parse logs is "Unreachable code. The previous statement stops further execution." From 163d5f2554ab1f04504e06649fbbfc1a1ffe5449 Mon Sep 17 00:00:00 2001 From: Patrick Miller Date: Wed, 12 Aug 2026 13:59:28 -0400 Subject: [PATCH 3/3] Allow suppressing as a section --- .../skript/common/CommonModule.java | 4 +- ...ints.java => EffSecSuppressTypeHints.java} | 28 +++++++++--- ...nings.java => EffSecSuppressWarnings.java} | 45 ++++++++++++++----- .../tests/common/EffSuppressWarnings.sk | 11 +++++ src/test/skript/tests/misc/type hints.sk | 5 +-- 5 files changed, 70 insertions(+), 23 deletions(-) rename src/main/java/org/skriptlang/skript/common/elements/effects/{EffSuppressTypeHints.java => EffSecSuppressTypeHints.java} (67%) rename src/main/java/org/skriptlang/skript/common/elements/effects/{EffSuppressWarnings.java => EffSecSuppressWarnings.java} (58%) diff --git a/src/main/java/org/skriptlang/skript/common/CommonModule.java b/src/main/java/org/skriptlang/skript/common/CommonModule.java index fed30521d6c..c94012adb6e 100644 --- a/src/main/java/org/skriptlang/skript/common/CommonModule.java +++ b/src/main/java/org/skriptlang/skript/common/CommonModule.java @@ -31,8 +31,8 @@ protected void initSelf(SkriptAddon addon) { @Override protected void loadSelf(SkriptAddon addon) { register(addon, - EffSuppressTypeHints::register, - EffSuppressWarnings::register, + EffSecSuppressTypeHints::register, + EffSecSuppressWarnings::register, ExprColorFromHexCode::register, ExprHexCode::register, ExprRecursiveSize::register, diff --git a/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressTypeHints.java b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSecSuppressTypeHints.java similarity index 67% rename from src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressTypeHints.java rename to src/main/java/org/skriptlang/skript/common/elements/effects/EffSecSuppressTypeHints.java index 1b72debe228..030fc786f27 100644 --- a/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressTypeHints.java +++ b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSecSuppressTypeHints.java @@ -1,13 +1,16 @@ package org.skriptlang.skript.common.elements.effects; +import ch.njol.skript.config.SectionNode; 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.EffectSection; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.lang.TriggerItem; import ch.njol.skript.registrations.Feature; +import ch.njol.skript.variables.HintManager; import ch.njol.util.Kleenean; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; @@ -16,6 +19,8 @@ import org.skriptlang.skript.registration.SyntaxInfo; import org.skriptlang.skript.registration.SyntaxRegistry; +import java.util.List; + @Name("Suppress Type Hints (Experimental)") @Description(""" An effect to suppress local variable type hint errors for the syntax lines that follow this effect. @@ -27,13 +32,13 @@ # potentially unsafe code goes here stop suppressing local variable type hints """) -@Since("2.12") -public class EffSuppressTypeHints extends Effect implements SimpleExperimentalSyntax { +@Since({"2.12", "INSERT VERSION (suppressing in a section)"}) +public class EffSecSuppressTypeHints extends EffectSection implements SimpleExperimentalSyntax { private static final ExperimentData EXPERIMENT_DATA = ExperimentData.createSingularData(Feature.TYPE_HINTS); public static void register(SyntaxRegistry syntaxRegistry) { - syntaxRegistry.register(SyntaxRegistry.EFFECT, SyntaxInfo.simple(EffSuppressTypeHints.class, EffSuppressTypeHints::new, + syntaxRegistry.register(SyntaxRegistry.SECTION, SyntaxInfo.simple(EffSecSuppressTypeHints.class, EffSecSuppressTypeHints::new, "[stop:un]suppress [local variable] type hints", "(start|:stop) suppressing [local variable] type hints")); } @@ -41,14 +46,23 @@ public static void register(SyntaxRegistry syntaxRegistry) { private boolean stopSuppression; @Override - public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult, + @Nullable SectionNode sectionNode, @Nullable List triggerItems) { stopSuppression = parseResult.hasTag("stop"); - getParser().getHintManager().setActive(stopSuppression); + HintManager hintManager = getParser().getHintManager(); + boolean wasActive = hintManager.isActive(); + hintManager.setActive(stopSuppression); + if (sectionNode != null) { + loadCode(sectionNode); + hintManager.setActive(wasActive); + } return true; } @Override - protected void execute(Event event) { } + protected @Nullable TriggerItem walk(Event event) { + return walk(event, true); + } @Override public String toString(@Nullable Event event, boolean debug) { diff --git a/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSecSuppressWarnings.java similarity index 58% rename from src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java rename to src/main/java/org/skriptlang/skript/common/elements/effects/EffSecSuppressWarnings.java index 6fa25cb3c40..cf30eaadb85 100644 --- a/src/main/java/org/skriptlang/skript/common/elements/effects/EffSuppressWarnings.java +++ b/src/main/java/org/skriptlang/skript/common/elements/effects/EffSecSuppressWarnings.java @@ -1,26 +1,32 @@ package org.skriptlang.skript.common.elements.effects; import ch.njol.skript.Skript; +import ch.njol.skript.config.SectionNode; 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.EffectSection; import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.lang.TriggerItem; +import ch.njol.skript.lang.parser.ParserInstance; import ch.njol.util.Kleenean; import org.bukkit.event.Event; import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.lang.script.Script; import org.skriptlang.skript.lang.script.ScriptWarning; import org.skriptlang.skript.registration.SyntaxInfo; import org.skriptlang.skript.registration.SyntaxRegistry; +import java.util.List; + @Name("Locally Suppress Warning") @Description("Suppresses target warnings from the current script.") @Example("locally suppress missing conjunction warnings") @Example("suppress the variable save warnings") -@Since("2.3") -public class EffSuppressWarnings extends Effect { +@Since({"2.3", "INSERT VERSION (suppressing in a section)"}) +public class EffSecSuppressWarnings extends EffectSection { public static void register(SyntaxRegistry syntaxRegistry) { StringBuilder warnings = new StringBuilder(); @@ -33,7 +39,7 @@ public static void register(SyntaxRegistry syntaxRegistry) { .append(':') .append(values[i].getPattern()); } - syntaxRegistry.register(SyntaxRegistry.EFFECT, SyntaxInfo.simple(EffSuppressWarnings.class, EffSuppressWarnings::new, + syntaxRegistry.register(SyntaxRegistry.SECTION, SyntaxInfo.simple(EffSecSuppressWarnings.class, EffSecSuppressWarnings::new, "[local[ly]] [stop:un]suppress [the] (" + warnings + ") warning[s]", "[start|:stop] [local[ly]] suppressing [the] (" + warnings + ") warning[s]")); } @@ -42,8 +48,10 @@ public static void register(SyntaxRegistry syntaxRegistry) { private boolean stop; @Override - public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) { - if (!getParser().isActive()) { + public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult, + @Nullable SectionNode sectionNode, @Nullable List triggerItems) { + ParserInstance parser = getParser(); + if (!parser.isActive()) { Skript.error("You can't suppress warnings outside of a script!"); return false; } @@ -52,16 +60,31 @@ public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelaye stop = parseResult.hasTag("stop"); if (warning.isDeprecated()) { Skript.warning(warning.getDeprecationMessage()); - } else if (stop) { - getParser().getCurrentScript().allowWarning(warning); + } + + Script script = parser.getCurrentScript(); + boolean wasSuppressed = script.suppressesWarning(warning); + if (stop) { + script.allowWarning(warning); } else { - getParser().getCurrentScript().suppressWarning(warning); + script.suppressWarning(warning); } + if (sectionNode != null) { + loadCode(sectionNode); + if (wasSuppressed) { + script.suppressWarning(warning); + } else { + script.allowWarning(warning); + } + } + return true; } @Override - protected void execute(Event event) { } + protected @Nullable TriggerItem walk(Event event) { + return walk(event, true); + } @Override public String toString(@Nullable Event event, boolean debug) { diff --git a/src/test/skript/tests/common/EffSuppressWarnings.sk b/src/test/skript/tests/common/EffSuppressWarnings.sk index 5058ba94af0..c1a4f21c915 100644 --- a/src/test/skript/tests/common/EffSuppressWarnings.sk +++ b/src/test/skript/tests/common/EffSuppressWarnings.sk @@ -16,3 +16,14 @@ test "EffSuppressWarnings": stop stop assert last parse logs is "Unreachable code. The previous statement stops further execution." + + suppress unreachable code warnings: + parse: + stop + stop + assert last parse logs is not set + + parse: + stop + stop + assert last parse logs is "Unreachable code. The previous statement stops further execution." diff --git a/src/test/skript/tests/misc/type hints.sk b/src/test/skript/tests/misc/type hints.sk index 09b3f7df10d..a578e628b88 100644 --- a/src/test/skript/tests/misc/type hints.sk +++ b/src/test/skript/tests/misc/type hints.sk @@ -17,9 +17,8 @@ test "type hints": set {_a} to {_x} in lowercase unsuppress local variable type hints set {_x} to 10 - suppress local variable type hints - set {_a} to {_x} in lowercase - unsuppress local variable type hints + suppress local variable type hints: + set {_a} to {_x} in lowercase assert last parse logs is not set with "last parse logs is set (%last parse logs%)" delete {_x}