From ae1c585dcc727bd4995c3b819423d473dacf6957 Mon Sep 17 00:00:00 2001 From: Ricardo Costa Date: Sat, 21 Mar 2026 18:24:14 +0000 Subject: [PATCH 1/5] Instance Variable Superscript Notation --- .../diagnostics/errors/RefinementError.java | 10 +++- .../errors/StateRefinementError.java | 10 ++-- .../derivation_node/ValDerivationNode.java | 23 ++++---- .../derivation_node/VarDerivationNode.java | 18 ++++++ .../utils/VariableNameFormatter.java | 55 +++++++++++++++++++ .../utils/VariableNameFormatterTest.java | 29 ++++++++++ 6 files changed, 127 insertions(+), 18 deletions(-) create mode 100644 liquidjava-verifier/src/main/java/liquidjava/utils/VariableNameFormatter.java create mode 100644 liquidjava-verifier/src/test/java/liquidjava/utils/VariableNameFormatterTest.java diff --git a/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/RefinementError.java b/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/RefinementError.java index 380edf9a..7640d892 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/RefinementError.java +++ b/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/RefinementError.java @@ -7,6 +7,7 @@ import liquidjava.diagnostics.TranslationTable; import liquidjava.rj_language.opt.derivation_node.ValDerivationNode; import liquidjava.smt.Counterexample; +import liquidjava.utils.VariableNameFormatter; import spoon.reflect.cu.SourcePosition; /** @@ -22,7 +23,10 @@ public class RefinementError extends LJError { public RefinementError(SourcePosition position, ValDerivationNode expected, ValDerivationNode found, TranslationTable translationTable, Counterexample counterexample, String customMessage) { - super("Refinement Error", String.format("%s is not a subtype of %s", found.getValue(), expected.getValue()), + super("Refinement Error", + String.format("%s is not a subtype of %s", + VariableNameFormatter.formatText(found.getValue().toString()), + VariableNameFormatter.formatText(expected.getValue().toString())), position, translationTable, customMessage); this.expected = expected; this.found = found; @@ -47,7 +51,7 @@ public String getCounterExampleString() { // only include variables that appear in the found value .filter(a -> foundVarNames.contains(a.first())) // format as "var == value" - .map(a -> a.first() + " == " + a.second()) + .map(a -> VariableNameFormatter.formatVariable(a.first()) + " == " + a.second()) // join with "&&" .collect(Collectors.joining(" && ")); @@ -68,4 +72,4 @@ public ValDerivationNode getExpected() { public ValDerivationNode getFound() { return found; } -} \ No newline at end of file +} diff --git a/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/StateRefinementError.java b/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/StateRefinementError.java index 976508cf..ea7bf4dd 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/StateRefinementError.java +++ b/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/StateRefinementError.java @@ -2,6 +2,7 @@ import liquidjava.diagnostics.TranslationTable; import liquidjava.rj_language.ast.Expression; +import liquidjava.utils.VariableNameFormatter; import spoon.reflect.cu.SourcePosition; /** @@ -17,10 +18,11 @@ public class StateRefinementError extends LJError { public StateRefinementError(SourcePosition position, Expression expected, Expression found, TranslationTable translationTable, String customMessage) { super("State Refinement Error", - String.format("Expected state %s but found %s", expected.toString(), found.toString()), position, - translationTable, customMessage); - this.expected = expected.toString(); - this.found = found.toString(); + String.format("Expected state %s but found %s", VariableNameFormatter.formatText(expected.toString()), + VariableNameFormatter.formatText(found.toString())), + position, translationTable, customMessage); + this.expected = VariableNameFormatter.formatText(expected.toString()); + this.found = VariableNameFormatter.formatText(found.toString()); } public String getExpected() { diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/ValDerivationNode.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/ValDerivationNode.java index 64eb4fad..56a15315 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/ValDerivationNode.java +++ b/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/ValDerivationNode.java @@ -15,6 +15,7 @@ import liquidjava.rj_language.ast.LiteralLong; import liquidjava.rj_language.ast.LiteralReal; import liquidjava.rj_language.ast.Var; +import liquidjava.utils.VariableNameFormatter; public class ValDerivationNode extends DerivationNode { @@ -41,17 +42,17 @@ private static class ExpressionSerializer implements JsonSerializer public JsonElement serialize(Expression exp, Type typeOfSrc, JsonSerializationContext context) { if (exp == null) return JsonNull.INSTANCE; - if (exp instanceof LiteralInt) - return new JsonPrimitive(((LiteralInt) exp).getValue()); - if (exp instanceof LiteralLong) - return new JsonPrimitive(((LiteralLong) exp).getValue()); - if (exp instanceof LiteralReal) - return new JsonPrimitive(((LiteralReal) exp).getValue()); - if (exp instanceof LiteralBoolean) - return new JsonPrimitive(exp.isBooleanTrue()); - if (exp instanceof Var) - return new JsonPrimitive(((Var) exp).getName()); - return new JsonPrimitive(exp.toString()); + if (exp instanceof LiteralInt v) + return new JsonPrimitive(v.getValue()); + if (exp instanceof LiteralLong v) + return new JsonPrimitive(v.getValue()); + if (exp instanceof LiteralReal v) + return new JsonPrimitive(v.getValue()); + if (exp instanceof LiteralBoolean v) + return new JsonPrimitive(v.isBooleanTrue()); + if (exp instanceof Var v) + return new JsonPrimitive(VariableNameFormatter.formatVariable(v.getName())); + return new JsonPrimitive(VariableNameFormatter.formatText(exp.toString())); } } } diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/VarDerivationNode.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/VarDerivationNode.java index c134a44e..3a60a32c 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/VarDerivationNode.java +++ b/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/VarDerivationNode.java @@ -1,7 +1,18 @@ package liquidjava.rj_language.opt.derivation_node; +import java.lang.reflect.Type; + +import com.google.gson.JsonElement; +import com.google.gson.JsonPrimitive; +import com.google.gson.JsonSerializationContext; +import com.google.gson.JsonSerializer; +import com.google.gson.annotations.JsonAdapter; + +import liquidjava.utils.VariableNameFormatter; + public class VarDerivationNode extends DerivationNode { + @JsonAdapter(VariableNameSerializer.class) private final String var; private final DerivationNode origin; @@ -22,4 +33,11 @@ public String getVar() { public DerivationNode getOrigin() { return origin; } + + private static class VariableNameSerializer implements JsonSerializer { + @Override + public JsonElement serialize(String src, Type typeOfSrc, JsonSerializationContext context) { + return new JsonPrimitive(VariableNameFormatter.formatVariable(src)); + } + } } diff --git a/liquidjava-verifier/src/main/java/liquidjava/utils/VariableNameFormatter.java b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableNameFormatter.java new file mode 100644 index 00000000..40d07c75 --- /dev/null +++ b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableNameFormatter.java @@ -0,0 +1,55 @@ +package liquidjava.utils; + +import java.util.Arrays; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public final class VariableNameFormatter { + private static final Pattern INSTACE_VAR_PATTERN = Pattern.compile("^#(.+)_([0-9]+)$"); + private static final Pattern INSTANCE_VAR_TEXT_PATTERN = Pattern.compile("#[^\\s,;:()\\[\\]{}]+_[0-9]+"); + private static final char[] SUPERSCRIPT_CHARS = { '⁰', '¹', '²', '³', '⁴', '⁵', '⁶', '⁷', '⁸', '⁹' }; + private static final String[] SPECIAL_IDENTIFIERS = { "fresh", "ret" }; + + public static String formatVariable(String name) { + if (name == null) + return null; + + Matcher matcher = INSTACE_VAR_PATTERN.matcher(name); + if (!matcher.matches()) + return name; + + String baseName = matcher.group(1); + String counter = matcher.group(2); + String prefix = isSpecialIdentifier(baseName) ? "#" : ""; + return prefix + baseName + toSuperscript(counter); + } + + public static String formatText(String text) { + if (text == null) + return null; + + Matcher textMatcher = INSTANCE_VAR_TEXT_PATTERN.matcher(text); + StringBuilder sb = new StringBuilder(); + while (textMatcher.find()) { + String token = textMatcher.group(); + textMatcher.appendReplacement(sb, Matcher.quoteReplacement(formatVariable(token))); + } + textMatcher.appendTail(sb); + return sb.toString(); + } + + private static String toSuperscript(String number) { + StringBuilder sb = new StringBuilder(number.length()); + for (char c : number.toCharArray()) { + int index = c - '0'; + if (index < 0 || index >= SUPERSCRIPT_CHARS.length) + return number; + sb.append(SUPERSCRIPT_CHARS[index]); + } + return sb.toString(); + } + + private static boolean isSpecialIdentifier(String id) { + return Arrays.stream(SPECIAL_IDENTIFIERS).anyMatch(s -> s.equals(id)); + } +} diff --git a/liquidjava-verifier/src/test/java/liquidjava/utils/VariableNameFormatterTest.java b/liquidjava-verifier/src/test/java/liquidjava/utils/VariableNameFormatterTest.java new file mode 100644 index 00000000..e77f3aeb --- /dev/null +++ b/liquidjava-verifier/src/test/java/liquidjava/utils/VariableNameFormatterTest.java @@ -0,0 +1,29 @@ +package liquidjava.utils; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import liquidjava.rj_language.ast.Var; +import liquidjava.rj_language.opt.derivation_node.ValDerivationNode; +import liquidjava.rj_language.opt.derivation_node.VarDerivationNode; +import org.junit.jupiter.api.Test; + +class VariableNameFormatterTest { + + @Test + void testInstanceVariableDisplayNameFormatting() { + assertEquals("x", VariableNameFormatter.formatVariable("x")); + assertEquals("x²", VariableNameFormatter.formatVariable("#x_2")); + assertEquals("#fresh¹²", VariableNameFormatter.formatVariable("#fresh_12")); + assertEquals("#ret³", VariableNameFormatter.formatVariable("#ret_3")); + assertEquals("this#Class", VariableNameFormatter.formatVariable("this#Class")); + } + + @Test + void testDerivationNodeUsesSuperscriptNotation() { + ValDerivationNode node = new ValDerivationNode(new Var("#x_2"), new VarDerivationNode("#x_2")); + String serialized = node.toString(); + assertTrue(serialized.contains("\"value\": \"x²\""), "Expected derivation value to use superscript notation"); + assertTrue(serialized.contains("\"var\": \"x²\""), "Expected derivation origin to use superscript notation"); + } +} From 0c1b4802d751765e81727ec1a1067fcdd33bbab6 Mon Sep 17 00:00:00 2001 From: Ricardo Costa Date: Sat, 21 Mar 2026 18:39:33 +0000 Subject: [PATCH 2/5] Refactoring --- .../diagnostics/errors/RefinementError.java | 9 ++++----- .../diagnostics/errors/StateRefinementError.java | 11 +++++------ .../opt/derivation_node/ValDerivationNode.java | 6 +++--- .../opt/derivation_node/VarDerivationNode.java | 4 ++-- ...NameFormatter.java => VariableFormatter.java} | 2 +- .../VariableFormatterTest.java} | 16 +++++++++------- 6 files changed, 24 insertions(+), 24 deletions(-) rename liquidjava-verifier/src/main/java/liquidjava/utils/{VariableNameFormatter.java => VariableFormatter.java} (97%) rename liquidjava-verifier/src/test/java/liquidjava/{utils/VariableNameFormatterTest.java => variable_formatter/VariableFormatterTest.java} (63%) diff --git a/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/RefinementError.java b/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/RefinementError.java index 7640d892..815155e5 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/RefinementError.java +++ b/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/RefinementError.java @@ -7,7 +7,7 @@ import liquidjava.diagnostics.TranslationTable; import liquidjava.rj_language.opt.derivation_node.ValDerivationNode; import liquidjava.smt.Counterexample; -import liquidjava.utils.VariableNameFormatter; +import liquidjava.utils.VariableFormatter; import spoon.reflect.cu.SourcePosition; /** @@ -24,9 +24,8 @@ public class RefinementError extends LJError { public RefinementError(SourcePosition position, ValDerivationNode expected, ValDerivationNode found, TranslationTable translationTable, Counterexample counterexample, String customMessage) { super("Refinement Error", - String.format("%s is not a subtype of %s", - VariableNameFormatter.formatText(found.getValue().toString()), - VariableNameFormatter.formatText(expected.getValue().toString())), + String.format("%s is not a subtype of %s", VariableFormatter.formatText(found.getValue().toString()), + VariableFormatter.formatText(expected.getValue().toString())), position, translationTable, customMessage); this.expected = expected; this.found = found; @@ -51,7 +50,7 @@ public String getCounterExampleString() { // only include variables that appear in the found value .filter(a -> foundVarNames.contains(a.first())) // format as "var == value" - .map(a -> VariableNameFormatter.formatVariable(a.first()) + " == " + a.second()) + .map(a -> VariableFormatter.formatVariable(a.first()) + " == " + a.second()) // join with "&&" .collect(Collectors.joining(" && ")); diff --git a/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/StateRefinementError.java b/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/StateRefinementError.java index ea7bf4dd..1e83a2bc 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/StateRefinementError.java +++ b/liquidjava-verifier/src/main/java/liquidjava/diagnostics/errors/StateRefinementError.java @@ -2,7 +2,7 @@ import liquidjava.diagnostics.TranslationTable; import liquidjava.rj_language.ast.Expression; -import liquidjava.utils.VariableNameFormatter; +import liquidjava.utils.VariableFormatter; import spoon.reflect.cu.SourcePosition; /** @@ -17,12 +17,11 @@ public class StateRefinementError extends LJError { public StateRefinementError(SourcePosition position, Expression expected, Expression found, TranslationTable translationTable, String customMessage) { - super("State Refinement Error", - String.format("Expected state %s but found %s", VariableNameFormatter.formatText(expected.toString()), - VariableNameFormatter.formatText(found.toString())), + super("State Refinement Error", String.format("Expected state %s but found %s", + VariableFormatter.formatText(expected.toString()), VariableFormatter.formatText(found.toString())), position, translationTable, customMessage); - this.expected = VariableNameFormatter.formatText(expected.toString()); - this.found = VariableNameFormatter.formatText(found.toString()); + this.expected = VariableFormatter.formatText(expected.toString()); + this.found = VariableFormatter.formatText(found.toString()); } public String getExpected() { diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/ValDerivationNode.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/ValDerivationNode.java index 56a15315..be9afb00 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/ValDerivationNode.java +++ b/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/ValDerivationNode.java @@ -15,7 +15,7 @@ import liquidjava.rj_language.ast.LiteralLong; import liquidjava.rj_language.ast.LiteralReal; import liquidjava.rj_language.ast.Var; -import liquidjava.utils.VariableNameFormatter; +import liquidjava.utils.VariableFormatter; public class ValDerivationNode extends DerivationNode { @@ -51,8 +51,8 @@ public JsonElement serialize(Expression exp, Type typeOfSrc, JsonSerializationCo if (exp instanceof LiteralBoolean v) return new JsonPrimitive(v.isBooleanTrue()); if (exp instanceof Var v) - return new JsonPrimitive(VariableNameFormatter.formatVariable(v.getName())); - return new JsonPrimitive(VariableNameFormatter.formatText(exp.toString())); + return new JsonPrimitive(VariableFormatter.formatVariable(v.getName())); + return new JsonPrimitive(VariableFormatter.formatText(exp.toString())); } } } diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/VarDerivationNode.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/VarDerivationNode.java index 3a60a32c..a8dce4c5 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/VarDerivationNode.java +++ b/liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/derivation_node/VarDerivationNode.java @@ -8,7 +8,7 @@ import com.google.gson.JsonSerializer; import com.google.gson.annotations.JsonAdapter; -import liquidjava.utils.VariableNameFormatter; +import liquidjava.utils.VariableFormatter; public class VarDerivationNode extends DerivationNode { @@ -37,7 +37,7 @@ public DerivationNode getOrigin() { private static class VariableNameSerializer implements JsonSerializer { @Override public JsonElement serialize(String src, Type typeOfSrc, JsonSerializationContext context) { - return new JsonPrimitive(VariableNameFormatter.formatVariable(src)); + return new JsonPrimitive(VariableFormatter.formatVariable(src)); } } } diff --git a/liquidjava-verifier/src/main/java/liquidjava/utils/VariableNameFormatter.java b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java similarity index 97% rename from liquidjava-verifier/src/main/java/liquidjava/utils/VariableNameFormatter.java rename to liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java index 40d07c75..95c53a02 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/utils/VariableNameFormatter.java +++ b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java @@ -4,7 +4,7 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -public final class VariableNameFormatter { +public final class VariableFormatter { private static final Pattern INSTACE_VAR_PATTERN = Pattern.compile("^#(.+)_([0-9]+)$"); private static final Pattern INSTANCE_VAR_TEXT_PATTERN = Pattern.compile("#[^\\s,;:()\\[\\]{}]+_[0-9]+"); private static final char[] SUPERSCRIPT_CHARS = { '⁰', '¹', '²', '³', '⁴', '⁵', '⁶', '⁷', '⁸', '⁹' }; diff --git a/liquidjava-verifier/src/test/java/liquidjava/utils/VariableNameFormatterTest.java b/liquidjava-verifier/src/test/java/liquidjava/variable_formatter/VariableFormatterTest.java similarity index 63% rename from liquidjava-verifier/src/test/java/liquidjava/utils/VariableNameFormatterTest.java rename to liquidjava-verifier/src/test/java/liquidjava/variable_formatter/VariableFormatterTest.java index e77f3aeb..98e52ea0 100644 --- a/liquidjava-verifier/src/test/java/liquidjava/utils/VariableNameFormatterTest.java +++ b/liquidjava-verifier/src/test/java/liquidjava/variable_formatter/VariableFormatterTest.java @@ -1,4 +1,4 @@ -package liquidjava.utils; +package liquidjava.variable_formatter; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; @@ -6,17 +6,19 @@ import liquidjava.rj_language.ast.Var; import liquidjava.rj_language.opt.derivation_node.ValDerivationNode; import liquidjava.rj_language.opt.derivation_node.VarDerivationNode; +import liquidjava.utils.VariableFormatter; + import org.junit.jupiter.api.Test; -class VariableNameFormatterTest { +class VariableFormatterTest { @Test void testInstanceVariableDisplayNameFormatting() { - assertEquals("x", VariableNameFormatter.formatVariable("x")); - assertEquals("x²", VariableNameFormatter.formatVariable("#x_2")); - assertEquals("#fresh¹²", VariableNameFormatter.formatVariable("#fresh_12")); - assertEquals("#ret³", VariableNameFormatter.formatVariable("#ret_3")); - assertEquals("this#Class", VariableNameFormatter.formatVariable("this#Class")); + assertEquals("x", VariableFormatter.formatVariable("x")); + assertEquals("x²", VariableFormatter.formatVariable("#x_2")); + assertEquals("#fresh¹²", VariableFormatter.formatVariable("#fresh_12")); + assertEquals("#ret³", VariableFormatter.formatVariable("#ret_3")); + assertEquals("this#Class", VariableFormatter.formatVariable("this#Class")); } @Test From 2b2a3d8c7d42c1b78246109ea60bd003c33cdb76 Mon Sep 17 00:00:00 2001 From: Ricardo Costa Date: Sat, 21 Mar 2026 18:42:59 +0000 Subject: [PATCH 3/5] Minor Change --- .../src/main/java/liquidjava/utils/VariableFormatter.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java index 95c53a02..dc4ea4d8 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java +++ b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java @@ -1,6 +1,5 @@ package liquidjava.utils; -import java.util.Arrays; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -8,7 +7,6 @@ public final class VariableFormatter { private static final Pattern INSTACE_VAR_PATTERN = Pattern.compile("^#(.+)_([0-9]+)$"); private static final Pattern INSTANCE_VAR_TEXT_PATTERN = Pattern.compile("#[^\\s,;:()\\[\\]{}]+_[0-9]+"); private static final char[] SUPERSCRIPT_CHARS = { '⁰', '¹', '²', '³', '⁴', '⁵', '⁶', '⁷', '⁸', '⁹' }; - private static final String[] SPECIAL_IDENTIFIERS = { "fresh", "ret" }; public static String formatVariable(String name) { if (name == null) @@ -50,6 +48,6 @@ private static String toSuperscript(String number) { } private static boolean isSpecialIdentifier(String id) { - return Arrays.stream(SPECIAL_IDENTIFIERS).anyMatch(s -> s.equals(id)); + return id == "fresh" || id == "ret"; } } From 197893efcf656ff68060d286852a8cbaaeac06e2 Mon Sep 17 00:00:00 2001 From: Ricardo Costa Date: Sat, 21 Mar 2026 18:45:13 +0000 Subject: [PATCH 4/5] Fix --- .../src/main/java/liquidjava/utils/VariableFormatter.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java index dc4ea4d8..3bc3a707 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java +++ b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java @@ -48,6 +48,6 @@ private static String toSuperscript(String number) { } private static boolean isSpecialIdentifier(String id) { - return id == "fresh" || id == "ret"; + return "fresh".equals(id) || "ret".equals(id); } } From 2b771b2515db517be56ca0bb5c08c8e3cf271a18 Mon Sep 17 00:00:00 2001 From: Ricardo Costa Date: Sat, 21 Mar 2026 18:46:05 +0000 Subject: [PATCH 5/5] Minor Change --- .../src/main/java/liquidjava/utils/VariableFormatter.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java index 3bc3a707..0629fbff 100644 --- a/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java +++ b/liquidjava-verifier/src/main/java/liquidjava/utils/VariableFormatter.java @@ -48,6 +48,6 @@ private static String toSuperscript(String number) { } private static boolean isSpecialIdentifier(String id) { - return "fresh".equals(id) || "ret".equals(id); + return id.equals("fresh") || id.equals("ret"); } }