Re-think unary call site test structure

For clarity, we separate our tests of correctness and re-linking.
We make the tests work with a mixture types and parameterise the
operation, and that way end up with fewer test methods.

Author: jeff5

rt4core/src/main/java/uk/co/farowl/vsj4/core/PyFloat.java

@@ -140,6 +140,9 @@ public static double asDouble(Object o)
             throw Abstract.requiredTypeError("a real number", o);
     }
 
+    @Override
+    public String toString() { return PyUtil.defaultToString(this); }
+
     // Constructor from Python ----------------------------------------
 
     /**

rt4core/src/main/java/uk/co/farowl/vsj4/core/PyRT.java

@@ -22,29 +22,28 @@
 import uk.co.farowl.vsj4.support.InterpreterError;
 
 /**
- * Run-time support for JVM-compiled code (including
- * {@code invokedynamic} call sites). In some ways, this is the
- * companion to {@link Abstract}, which supports the interpretation of
- * Python byte code, providing access to special methods on Python
- * objects, through a regular Java API called with self-type
- * {@code Object}. Here, in contrast, we provide access to the same
- * special methods through the {@code invokedynamic} mechanism, for the
- * benefit of Java byte code call sites emitted by the Python compiler.
+ * {@link PyRT} provides run-time support for Python that has been
+ * compiled to Java byte code, primarily for {@code invokedynamic} call
+ * sites. In some ways, this supersedes methods in {@link Abstract} that
+ * support the interpretation of Python byte code. Like those methods,
+ * these call sites often wrap a call on a particular special method.
+ * Call sites in Java code should behave exactly as their counterparts
+ * in {@link Abstract}.
  * <p>
  * The use of {@code invokedynamic} call sites in compiled code offers a
  * greater potential for dynamic optimisation through specialisation to
  * the actual Java classes encountered in a given place. (It does not
- * benefit code like that in {@link Abstract} which receives many
- * different types.)
+ * benefit widely used code that receives calls with many different
+ * object types.)
  * <p>
  * The fact that this specialisation is on Java class rather than Python
  * type has two implications.
  * <ol>
  * <li>Primitive operations on simple types (like {@code int.__neg__})
- * dispatch quickly to their exact target implementation</li>
- * <li>Python types that share an implementation class, largely those
- * defined in Python, dispatch through a lookup on their particular type
- * object.</li>
+ * dispatch quickly to their exact target implementation.</li>
+ * <li>Operations on Python types that share an implementation class,
+ * largely those defined in Python, must find their target in a second
+ * step via the Python type of {@code self}.</li>
  * </ol>
  */
 public class PyRT {
@@ -100,6 +99,8 @@ public static CallSite bootstrap(Lookup lookup, String name,
             // TODO Maybe use AST node names/enum for call sites?
             case "negative" -> new UnaryOpCallSite(
                     SpecialMethod.op_neg);
+            case "absolute" -> new UnaryOpCallSite(
+                    SpecialMethod.op_abs);
             case "add" -> new BinaryOpCallSite(SpecialMethod.op_add);
             case "multiply" -> new BinaryOpCallSite(
                     SpecialMethod.op_mul);
@@ -112,8 +113,6 @@ public static CallSite bootstrap(Lookup lookup, String name,
         return site;
     }
 
-    // enum Validity {CLASS, TYPE, INSTANCE, ONCE}
-
     /**
      * A call site for unary Python operations. The call site is
      * constructed from a slot such as {@link SpecialMethod#op_neg}. It
@@ -123,6 +122,9 @@ public static CallSite bootstrap(Lookup lookup, String name,
      */
     static class UnaryOpCallSite extends MutableCallSite {
 
+        /** Limit on {@link #chainLength}. */
+        public static final int MAX_CHAIN = 4;
+
         /**
          * Handle to {@link #fallback(Object)}, which is the behaviour
          * for this call site when the class of {@code self} does not
@@ -138,8 +140,8 @@ static class UnaryOpCallSite extends MutableCallSite {
             }
         }
 
-        /** The abstract operation to be applied by the site. */
-        private final SpecialMethod op;
+        /** The {@link SpecialMethod} to be applied by the site. */
+        final SpecialMethod op;
 
         /**
          * The number of times this site has used
@@ -148,6 +150,14 @@ static class UnaryOpCallSite extends MutableCallSite {
          */
         int fallbackCount;
 
+        /**
+         * The number of guarded invocations cached in the target of
+         * this site by {@link #fallback(Object) fallback}, used to
+         * observe internal working and potentially for de-optimisation
+         * decisions.
+         */
+        int chainLength;
+
         /**
          * Construct a call site with the specific unary operation.
          *
@@ -198,12 +208,13 @@ private Object fallback(Object self) throws Throwable {
              * If the type has chosen a generic handle, it is because
              * the meaning of the special method may change.
              */
-            if (mh != op.generic) {
+            if (mh != op.generic && chainLength < MAX_CHAIN) {
                 // MH for guarded invocation (becomes new target)
                 MethodHandle guardMH = CLASS_GUARD.bindTo(selfClass);
                 MethodHandle targetMH =
                         guardWithTest(guardMH, mh, getTarget());
                 setTarget(targetMH);
+                chainLength += 1;
             }
             return result;
         }

rt4core/src/main/java/uk/co/farowl/vsj4/kernel/BaseType.java

@@ -1,4 +1,4 @@
-// Copyright (c)2025 Jython Developers.
+// Copyright (c)2026 Jython Developers.
 // Licensed to PSF under a contributor agreement.
 package uk.co.farowl.vsj4.kernel;
 
@@ -1242,7 +1242,7 @@ void fillConstructorLookup(TypeSpec spec) {
     private void updateSpecialMethodCache(SpecialMethod sm,
             LookupResult result) {
 
-        if (sm.cache == null) {
+        if (sm.hasCache()) {
             // There is no cache for this special method. Ignore.
             return;
 

rt4core/src/main/java/uk/co/farowl/vsj4/kernel/SpecialMethod.java

@@ -795,16 +795,16 @@ Object slot(Object self) throws Throwable {
         Object meth = type.lookup(methodName);
         if (meth == null) { throw SMUtil.EMPTY; }
         // What kind of object did we find? (Could be anything.)
-        Representation rep = Representation.get(meth);
-        PyType methType = rep.pythonType(meth);
+        Representation methRep = Representation.get(meth);
+        PyType methType = methRep.pythonType(meth);
 
         if (methType.isMethodDescr()) {
             return Callables.call(meth, self);
         } else {
             // We might still have have to bind meth to self.
             if (methType.isDescr()) {
                 // Replace meth with result of descriptor binding.
-                meth = op_get.handle(rep).invokeExact(meth, self, type);
+                meth = methRep.op_get().invokeExact(meth, self, type);
             }
             // meth is now the thing to call.
             return Callables.call(meth);
@@ -833,16 +833,16 @@ Object slot(Object self, Object w) throws Throwable {
         Object meth = type.lookup(methodName);
         if (meth == null) { throw SMUtil.EMPTY; }
         // What kind of object did we find? (Could be anything.)
-        Representation rep = Representation.get(meth);
-        PyType methType = rep.pythonType(meth);
+        Representation methRep = Representation.get(meth);
+        PyType methType = methRep.pythonType(meth);
 
         if (methType.isMethodDescr()) {
             return Callables.call(meth, self, w);
         } else {
             // We might still have have to bind meth to self.
             if (methType.isDescr()) {
                 // Replace meth with result of descriptor binding.
-                meth = op_get.handle(rep).invokeExact(meth, self, type);
+                meth = methRep.op_get().invokeExact(meth, self, type);
             }
             // meth is now the thing to call.
             return Callables.call(meth, w);
@@ -872,16 +872,16 @@ Object slot(Object self, Object w, Object m) throws Throwable {
         Object meth = type.lookup(methodName);
         if (meth == null) { throw SMUtil.EMPTY; }
         // What kind of object did we find? (Could be anything.)
-        Representation rep = Representation.get(meth);
-        PyType methType = rep.pythonType(meth);
+        Representation methRep = Representation.get(meth);
+        PyType methType = methRep.pythonType(meth);
 
         if (methType.isMethodDescr()) {
             return Callables.call(meth, self, w, m);
         } else {
             // We might still have have to bind meth to self.
             if (methType.isDescr()) {
                 // Replace meth with result of descriptor binding.
-                meth = op_get.handle(rep).invokeExact(meth, self, type);
+                meth = methRep.op_get().invokeExact(meth, self, type);
             }
             // meth is now the thing to call.
             return Callables.call(meth, w, m);
@@ -913,16 +913,16 @@ Object slot(Object self, Object obj, PyType t) throws Throwable {
         Object meth = type.lookup(methodName);
         if (meth == null) { throw SMUtil.EMPTY; }
         // What kind of object did we find? (Could be anything.)
-        Representation rep = Representation.get(meth);
-        PyType methType = rep.pythonType(meth);
+        Representation methRep = Representation.get(meth);
+        PyType methType = methRep.pythonType(meth);
 
         if (methType.isMethodDescr()) {
             return Callables.call(meth, self, obj, t);
         } else {
             // We might still have have to bind meth to self.
             if (methType.isDescr()) {
                 // Replace meth with result of descriptor binding.
-                meth = op_get.handle(rep).invokeExact(meth, self, type);
+                meth = methRep.op_get().invokeExact(meth, self, type);
             }
             // meth is now the thing to call.
             return Callables.call(meth, obj, t);
@@ -947,6 +947,16 @@ public MethodHandle errorHandle() {
         return error;
     }
 
+    /**
+     * Whether this {@code SpecialMethod} has a corresponding cache in
+     * {@link Representation} objects. If not, the effective
+     * {@code MethodHandle} is always the {@link #generic} one.
+     *
+     * @param rep target {@code Representation}
+     * @param mh handle value to assign
+     */
+    public boolean hasCache() { return cache != null; }
+
     /**
      * Set the cache for this {@code SpecialMethod} in the
      * {@link Representation} to the given {@code MethodHandle}.