Resolve inherited public constants in field reads

Co-authored-by: Codex <noreply@openai.com>

Author: rcosta358

liquidjava-example/src/main/java/testSuite/classes/inherited_constant_correct/ImageWriteParamRefinements.java

@@ -0,0 +1,16 @@
+package testSuite.classes.inherited_constant_correct;
+
+import liquidjava.specification.ExternalRefinementsFor;
+import liquidjava.specification.Refinement;
+import liquidjava.specification.StateRefinement;
+import liquidjava.specification.StateSet;
+
+@StateSet({"start", "explicit"})
+@ExternalRefinementsFor("javax.imageio.ImageWriteParam")
+public interface ImageWriteParamRefinements {
+    @StateRefinement(to = "mode == 2 ? explicit(this) : start(this)")
+    void setCompressionMode(@Refinement("_ >= 0 && _ <= 3") int mode);
+
+    @StateRefinement(from = "explicit(this)")
+    void setCompressionQuality(@Refinement("_ >= 0.0 && _ <= 1.0") float quality);
+}

liquidjava-example/src/main/java/testSuite/classes/inherited_constant_correct/Repro.java

@@ -0,0 +1,13 @@
+package testSuite.classes.inherited_constant_correct;
+
+import javax.imageio.ImageIO;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.plugins.jpeg.JPEGImageWriteParam;
+
+public class Repro {
+    public static void main(String[] args) {
+        ImageWriteParam p = ImageIO.getImageWritersByFormatName("jpeg").next().getDefaultWriteParam();
+        p.setCompressionMode(JPEGImageWriteParam.MODE_EXPLICIT);
+        p.setCompressionQuality(0.5f);
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/utils/StaticConstants.java

@@ -30,8 +30,8 @@ private StaticConstants() {
      *
      * <p>
      * Tries the source AST first ({@link CtLiteral} initializer in Spoon's model), then reflection via
-     * {@link CtFieldReference#getActualField()} + {@link #readStaticFinal}. Returns {@code null} if the field isn't
-     * static-final, has a non-literal initializer, or any lookup step fails.
+     * {@link Class#getField(String)} + {@link #readStaticFinal} so inherited public constants are included. Returns
+     * {@code null} if the field isn't static-final, has a non-literal initializer, or any lookup step fails.
      *
      * @see #resolve(String, String, CtElement) sibling for refinement-string {@code Type.CONST} references
      */
@@ -43,8 +43,8 @@ public static Object resolve(CtFieldReference<?> ref) {
         if (v != null)
             return v;
         try {
-            return ref.getActualField()instanceof Field jf ? readStaticFinal(jf) : null;
-        } catch (RuntimeException | LinkageError ignored) {
+            return readStaticFinal(ref.getDeclaringType().getActualClass().getField(ref.getSimpleName()));
+        } catch (NoSuchFieldException | RuntimeException | LinkageError ignored) {
             // Spoon throws SpoonClassNotFoundException; reflection can throw LinkageError. Fall through.
             return null;
         }

liquidjava-verifier/src/test/java/liquidjava/utils/StaticConstantsTest.java

@@ -0,0 +1,49 @@
+package liquidjava.utils;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import org.junit.jupiter.api.Test;
+
+import spoon.Launcher;
+import spoon.reflect.code.CtFieldRead;
+import spoon.reflect.visitor.filter.TypeFilter;
+
+class StaticConstantsTest {
+    @Test
+    void resolvesInheritedLibraryConstant() {
+        assertEquals(2, resolveRead(
+                "class Repro { int mode = javax.imageio.plugins.jpeg.JPEGImageWriteParam.MODE_EXPLICIT; }"));
+    }
+
+    @Test
+    void resolvesInheritedInterfaceConstant() {
+        assertEquals(0, resolveRead("class Repro { int alignment = javax.swing.JLabel.CENTER; }"));
+    }
+
+    @Test
+    void resolvesDeclaredLibraryConstant() {
+        assertEquals(2, resolveRead("class Repro { int mode = javax.imageio.ImageWriteParam.MODE_EXPLICIT; }"));
+    }
+
+    @Test
+    void resolvesPrivateSourceConstant() {
+        assertEquals(3, resolveRead("class Repro { private static final int LIMIT = 3; int value = LIMIT; }"));
+    }
+
+    @Test
+    void rejectsMutableSourceField() {
+        assertNull(resolveRead("class Repro { static int LIMIT = 3; int value = LIMIT; }"));
+    }
+
+    @Test
+    void rejectsInstanceSourceField() {
+        assertNull(resolveRead("class Repro { final int LIMIT = 3; int value = LIMIT; }"));
+    }
+
+    private static Object resolveRead(String source) {
+        var type = Launcher.parseClass(source);
+        CtFieldRead<?> read = type.getElements(new TypeFilter<>(CtFieldRead.class)).get(0);
+        return StaticConstants.resolve(read.getVariable());
+    }
+}