Recognise iterable and sequence type

Make sequence operation on PyUnicode work (some of them) by introducing
quick tests for the presence of the relevant special methods.

Author: jeff5

rt4core/src/kernelTest/java/uk/co/farowl/vsj4/runtime/kernel/TypeFactoryTest.java

@@ -9,6 +9,7 @@
 
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodHandles.Lookup;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 
@@ -61,6 +62,11 @@ public void exposeMethods(Class<?> definingClass) {}
                 @Override
                 public void populate(Map<? super String, Object> dict,
                         Lookup lookup) {}
+
+                @Override
+                public Iterable<Entry> entries(Lookup lookup) {
+                    return List.of();
+                }
             };
 
     /**

rt4core/src/main/java/uk/co/farowl/vsj4/runtime/Abstract.java

@@ -1,4 +1,4 @@
-// Copyright (c)2024 Jython Developers.
+// Copyright (c)2025 Jython Developers.
 // Licensed to PSF under a contributor agreement.
 package uk.co.farowl.vsj4.runtime;
 
@@ -135,10 +135,9 @@ public static <T> T tojava(Object o, Class<T> c) {
      * @throws Throwable on errors within {@code __hash__}
      */
     public static int hash(Object v) throws PyBaseException, Throwable {
+        Representation rep = PyType.getRepresentation(v);
         try {
-            Representation rep = PyType.getRepresentation(v);
-            MethodHandle mh = rep.op_hash();
-            return (int)mh.invokeExact(v);
+            return (int)rep.op_hash().invokeExact(v);
         } catch (EmptyException e) {
             throw typeError("unhashable type: %s", v);
         }
@@ -365,8 +364,8 @@ public static Object lookupAttr(Object o, Object name)
     public static void setAttr(Object o, String name, Object value)
             throws PyAttributeError, Throwable {
         // Decisions are based on type of o (that of name is known)
+        Representation rep = PyType.getRepresentation(o);
         try {
-            Representation rep = PyType.getRepresentation(o);
             rep.op_setattr().invokeExact(o, name, value);
         } catch (EmptyException e) {
             throw attributeAccessError(o, name,
@@ -408,8 +407,8 @@ public static void setAttr(Object o, Object name, Object value)
     public static void delAttr(Object o, String name)
             throws PyAttributeError, Throwable {
         // Decisions are based on type of o (that of name is known)
+        Representation rep = PyType.getRepresentation(o);
         try {
-            Representation rep = PyType.getRepresentation(o);
             rep.op_delattr().invokeExact(o, name);
         } catch (EmptyException e) {
             throw attributeAccessError(o, name,
@@ -731,9 +730,9 @@ private static Object lookupSpecial(Object self, String name)
             return null;
         } else {
             // res might be a descriptor
+            Representation rep = PyType.getRepresentation(res);
             try {
                 // invoke the descriptor's __get__
-                Representation rep = PyType.getRepresentation(res);
                 MethodHandle f = rep.op_get();
                 res = f.invokeExact(res, self, selfType);
             } catch (EmptyException e) {}
@@ -777,20 +776,26 @@ static Object getIterator(Object o)
     // Compare CPython PyObject_GetIter in abstract.c
     static <E extends PyBaseException> Object getIterator(Object o,
             Supplier<E> exc) throws PyBaseException, Throwable {
-        Representation rep = PyType.getRepresentation(o);
-        if (SpecialMethod.op_iter.isDefinedFor(rep)) {
-            // o defines __iter__, call it.
-            Object r = rep.op_iter().invokeExact(o);
-            // Did that return an iterator? Check r defines __next__.
-            if (SpecialMethod.op_next
-                    .isDefinedFor(PyType.getRepresentation(r))) {
-                return r;
+
+        Representation orep = PyType.getRepresentation(o);
+        PyType otype = orep.pythonType(o);
+
+        try {
+            // Call o.__iter__, which may be empty.
+            Object i = orep.op_iter().invokeExact(o);
+            // Did that return an iterator? Check i defines __next__.
+            Representation irep = PyType.getRepresentation(i);
+            if (irep.pythonType(i).isIterator()) {
+                return i;
             } else if (exc == null) {
-                throw returnTypeError("iter", "iterator", r);
+                throw returnTypeError("iter", "iterator", i);
+            }
+        } catch (EmptyException e) {
+            // otype does not define __iter__: try __getitem__
+            if (otype.isSequence()) {
+                // o defines __getitem__: make a (Python) iterator.
+                return new PyIterator(o);
             }
-        } else if (SpecialMethod.op_getitem.isDefinedFor(rep)) {
-            // o defines __getitem__: make a (Python) iterator.
-            return new PyIterator(o);
         }
 
         // Out of possibilities: throw caller-defined exception
@@ -809,8 +814,7 @@ static <E extends PyBaseException> Object getIterator(Object o,
      * @return true if {@code o} supports the iterator protocol
      */
     static boolean iterableCheck(Object o) {
-        return SpecialMethod.op_iter
-                .isDefinedFor(PyType.getRepresentation(o));
+        return PyType.of(o).isIterable();
     }
 
     /**
@@ -822,8 +826,7 @@ static boolean iterableCheck(Object o) {
      */
     // Compare CPython PyIter_Check in abstract.c
     static boolean iteratorCheck(Object o) {
-        return SpecialMethod.op_next
-                .isDefinedFor(PyType.getRepresentation(o));
+        return PyType.of(o).isIterator();
     }
 
     /**
@@ -855,15 +858,14 @@ static Object next(Object iter) throws Throwable {
      *
      * @param o object accessed
      * @param name of attribute
-     * @param slot operation
+     * @param sm operation
      * @return an error to throw
      */
     private static PyBaseException attributeAccessError(Object o,
-            String name, SpecialMethod slot) {
-        String mode, kind,
-                fmt = "'%.100s' object has %s attributes (%s.%.50s)";
+            String name, SpecialMethod sm) {
+        String mode, kind;
         // What were we trying to do?
-        switch (slot) {
+        switch (sm) {
             case op_delattr:
                 mode = "delete ";
                 break;
@@ -874,16 +876,17 @@ private static PyBaseException attributeAccessError(Object o,
                 mode = "";
                 break;
         }
-        // Can we even read this object's attributes?
+        // Can we even read the attribute?
         Representation rep = PyType.getRepresentation(o);
         String typeName = rep.pythonType(o).getName();
         boolean readable =
                 SpecialMethod.op_getattribute.isDefinedFor(rep)
                         || SpecialMethod.op_getattr.isDefinedFor(rep);
         kind = readable ? "only read-only" : "no";
         // Now we know what to say
-        return PyErr.format(PyExc.TypeError, fmt, typeName, kind, mode,
-                name);
+        return PyErr.format(PyExc.TypeError,
+                "'%.100s' object has %s attributes (%s '%.50s')",
+                typeName, kind, mode, name);
     }
 
     // Convenience functions constructing errors --------------------

rt4core/src/main/java/uk/co/farowl/vsj4/runtime/Feature.java

@@ -1,7 +1,7 @@
+// Copyright (c)2025 Jython Developers.
+// Licensed to PSF under a contributor agreement.
 package uk.co.farowl.vsj4.runtime;
 
-import uk.co.farowl.vsj4.runtime.kernel.TypeFlag;
-
 /**
  * Enumeration of the features of a type that may be specified in a
  * {@link TypeSpec}.
@@ -46,26 +46,21 @@ public enum Feature {
 
     /**
      * Instances of the type object are treated as sequences for pattern
-     * matching.
+     * matching. This does not affect whether Python treats instances as
+     * a sequence functionally, which depends instead on whether a type
+     * defines the required special methods.
      */
     // Compare CPython Py_TPFLAGS_SEQUENCE
     SEQUENCE(TypeFlag.SEQUENCE),
     /**
      * Instances of the type object are treated as mappings for pattern
-     * matching
+     * matching. This does not affect whether Python treats instances as
+     * a mapping functionally, which depends instead on whether a type
+     * defines the required special methods.
      */
     // Compare CPython Py_TPFLAGS_MAPPING
     MAPPING(TypeFlag.MAPPING),
 
-    /**
-     * This flag is used to give certain built-ins a pattern-matching
-     * behaviour that allows a single positional sub-pattern to match
-     * against the subject itself (rather than a mapped attribute on
-     * it).
-     */
-    // Compare CPython _Py_TPFLAGS_MATCH_SELF
-    MATCH_SELF(TypeFlag.MATCH_SELF),
-
     /**
      * An instance of this type is a method descriptor, that is, it
      * supports an optimised call pattern where a {@code self} argument
@@ -85,7 +80,7 @@ public enum Feature {
      * equivalent to {@code func(*args, **kwds)}.</li>
      * </ul>
      */
-    METHOD_DESCR(TypeFlag.IS_METHOD_DESCR);
+    METHOD_DESCR(TypeFlag.METHOD_DESCR);
 
     /** Navigate from feature to corresponding type flag. */
     public final TypeFlag flag;

rt4core/src/main/java/uk/co/farowl/vsj4/runtime/PyNameError.java

@@ -17,7 +17,7 @@ public class PyNameError extends PyBaseException {
                     .add(Feature.REPLACEABLE, Feature.IMMUTABLE)
                     .doc("Name not found globally."));
 
-    /** {@code UnboundLocalError} extends {@link NameError}. */
+    /** {@code UnboundLocalError} extends {@code NameError}. */
     protected static PyType UnboundLocalError =
             extendsException(TYPE, "UnboundLocalError",
                     "Local name referenced but not bound to a value.");

rt4core/src/main/java/uk/co/farowl/vsj4/runtime/PyNumber.java

@@ -1,4 +1,4 @@
-// Copyright (c)2024 Jython Developers.
+// Copyright (c)2025 Jython Developers.
 // Licensed to PSF under a contributor agreement.
 package uk.co.farowl.vsj4.runtime;
 
@@ -235,20 +235,22 @@ protected static boolean indexCheck(Object obj) {
     }
 
     /**
-     * Return a Python {@code int} (or subclass) from the object
-     * {@code o}. Raise {@code TypeError} if the result is not a Python
-     * {@code int} subclass, or if the object {@code o} cannot be
-     * interpreted as an index (it does not fill
-     * {@link SpecialMethod#op_index}). This method makes no guarantee
-     * about the <i>range</i> of the result.
+     * Interpret the argument {@code o} as an integer, returning a
+     * Python {@code int} (or subclass), by means of a call to
+     * the lossless conversion method
+     * {@code __index__}. Raise {@code TypeError} if the result is not a
+     * Python {@code int} subclass, or if the object {@code o} cannot be
+     * interpreted as an index (it does not define {@code __index__}.
+     * This method makes no guarantee about the <i>range</i> of the
+     * result.
      *
      * @param o operand
      * @return {@code o} coerced to a Python {@code int}
      * @throws PyBaseException (TypeError) if {@code o} cannot be
      *     interpreted as an {@code int}
      * @throws Throwable otherwise from invoked implementations
      */
-    // Compare with CPython abstract.c :: PyNumber_Index
+    // Compare with CPython abstract.c :: _PyNumber_Index
     static Object index(Object o) throws PyBaseException, Throwable {
 
         Representation rep = PyType.getRepresentation(o);

rt4core/src/main/java/uk/co/farowl/vsj4/runtime/PySequence.java

@@ -15,8 +15,8 @@
 
 import uk.co.farowl.vsj4.runtime.PySlice.Indices;
 import uk.co.farowl.vsj4.runtime.PyUtil.NoConversion;
+import uk.co.farowl.vsj4.runtime.kernel.KernelTypeFlag;
 import uk.co.farowl.vsj4.runtime.kernel.Representation;
-import uk.co.farowl.vsj4.runtime.kernel.SpecialMethod;
 import uk.co.farowl.vsj4.support.internal.EmptyException;
 
 /**
@@ -261,15 +261,17 @@ public static PyList list(Object o)
             fastNewList(Object o, Supplier<E> exc) throws E, Throwable {
         List<Object> list = new ArrayList<>();
         Representation rep = PyType.getRepresentation(o);
+        PyType type = rep.pythonType(o);
 
-        if (SpecialMethod.op_iter.isDefinedFor(rep)) {
+        if (type.hasFeature(KernelTypeFlag.HAS_ITER)) {
             // Go via the iterator on o
             Object iter = rep.op_iter().invokeExact(o);
             // Check iter is an iterator (defines __next__).
-            Representation iterOps = PyType.getRepresentation(iter);
-            if (SpecialMethod.op_next.isDefinedFor(iterOps)) {
+            Representation iterRep = PyType.getRepresentation(iter);
+            PyType iterType = iterRep.pythonType(iter);
+            if (iterType.hasFeature(KernelTypeFlag.HAS_NEXT)) {
                 // Create a handle on __next__
-                MethodHandle next = iterOps.op_next().bindTo(iter);
+                MethodHandle next = iterRep.op_next().bindTo(iter);
                 // Iterate o into a list
                 try {
                     for (;;) { list.add(next.invokeExact()); }
@@ -279,7 +281,7 @@ public static PyList list(Object o)
                 return list;
             } // else fall out at throw exc
 
-        } else if (SpecialMethod.op_getitem.isDefinedFor(rep)) {
+        } else if ((type.hasFeature(KernelTypeFlag.HAS_GETITEM))) {
             // o defines __getitem__
             MethodHandle getitem = rep.op_getitem().bindTo(o);
             try {

rt4core/src/main/java/uk/co/farowl/vsj4/runtime/TypeExposerImplementation.java

@@ -8,6 +8,7 @@
 import java.lang.invoke.MethodType;
 import java.lang.invoke.WrongMethodTypeException;
 import java.lang.reflect.Method;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -96,6 +97,47 @@ public void populate(Map<? super String, Object> dict,
         }
     }
 
+
+    @Override
+    public Iterable<Entry> entries(Lookup lookup) {
+        if (type == null)
+            // type may only properly be null during certain tests
+            throw new InterpreterError(
+                    "Cannot generate entries for type 'null'");
+        logger.atDebug().addArgument(type.getName())
+                .log("Populating type '{}'");
+
+        // The returned object will stream name-attr pairs
+        return new Iterable<Entry>() {
+
+            @Override
+            public Iterator<Entry> iterator() {
+                return new Iterator<Entry>() {
+                    // Entries derive from the specs table
+                    Iterator<Spec> specIter = specs.values().iterator();
+
+                    @Override
+                    public boolean hasNext() {
+                        // ... if there are specs left to process
+                        return specIter.hasNext();
+                    }
+
+                    @Override
+                    public Entry next() {
+                        Spec spec = specIter.next();
+                        logger.atTrace().addArgument(type.getName())
+                                .addArgument(spec.name)
+                                .log("-  Add {}.{}");
+                        spec.checkFormation();
+                        // Create attribute according to spec type
+                        Object attr = spec.asAttribute(type, lookup);
+                        return new Entry(spec.name, attr);
+                    }
+                };
+            }
+        };
+    }
+
     /**
      * Add to {@link #specs}, definitions based on methods found in the
      * given class and either annotated for exposure or having the name