Instance Variable Superscript Notation

rcosta358 · rcosta358 · commit ae1c585dcc72 · 2026-03-21T18:24:14.000Z
diff --git 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;
     }
-}
+}
diff --git 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
@@ -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<Expression>
         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
@@ -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<String> {
+        @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
@@ -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
@@ -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");
+    }
+}
