Minor refactorings

Author: steve-s

graalpython/com.oracle.graal.python.processor/src/com/oracle/graal/python/processor/SlotsProcessor.java

@@ -83,7 +83,7 @@ public static TpSlotData createHashNotImplemented(TypeElement enclosingType) {
 
         public String builderCall() {
             if (isHashNotImplemented()) {
-                return ".set(TpSlots.TpSlotMeta.TP_HASH, com.oracle.graal.python.builtins.objects.type.slots.PyObjectHashNotImplemented.INSTANCE)";
+                return ".set(TpSlots.TpSlotMeta.TP_HASH, com.oracle.graal.python.builtins.objects.type.slots.TpSlotHashFun.HASH_NOT_IMPLEMENTED)";
             }
             return String.format(".set(TpSlots.TpSlotMeta.%s, %s.INSTANCE)", //
                             slot.value().name().toUpperCase(Locale.ROOT), //

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/set/BaseSetBuiltins.java

@@ -78,8 +78,8 @@
 import com.oracle.graal.python.builtins.objects.type.TpSlots;
 import com.oracle.graal.python.builtins.objects.type.TpSlots.GetObjectSlotsNode;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes;
-import com.oracle.graal.python.builtins.objects.type.slots.PyObjectHashNotImplemented;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotBinaryOp.BinaryOpBuiltinNode;
+import com.oracle.graal.python.builtins.objects.type.slots.TpSlotHashFun;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotLen.LenBuiltinNode;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotRichCompare;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotSqContains.SqContainsBuiltinNode;
@@ -503,7 +503,7 @@ static Object doPSet(Node inliningTarget, PSet key,
             // come from the tp_hash implementation or from the tp_richcompare also called during
             // the search
             TpSlots slots = getSlotsNode.execute(inliningTarget, key);
-            if (slots.tp_hash() == null || slots.tp_hash() == PyObjectHashNotImplemented.INSTANCE) {
+            if (slots.tp_hash() == null || slots.tp_hash() == TpSlotHashFun.HASH_NOT_IMPLEMENTED) {
                 return PFactory.createFrozenSet(PythonLanguage.get(inliningTarget), copyNode.execute(inliningTarget, key.getDictStorage()));
             } else {
                 return key;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TpSlots.java

@@ -167,7 +167,6 @@
 import com.oracle.graal.python.builtins.objects.type.TpSlotsFactory.GetObjectSlotsNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TpSlotsFactory.GetTpSlotsNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes.GetSubclassesAsArrayNode;
-import com.oracle.graal.python.builtins.objects.type.slots.PyObjectHashNotImplemented;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlot;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotBuiltin;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotCExtNative;
@@ -186,6 +185,7 @@
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotDescrSet.TpSlotDescrSetPython;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotGetAttr.TpSlotGetAttrBuiltin;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotGetAttr.TpSlotGetAttrPython;
+import com.oracle.graal.python.builtins.objects.type.slots.TpSlotHashFun;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotHashFun.TpSlotHashBuiltin;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotInquiry.TpSlotInquiryBuiltin;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotIterNext;
@@ -1239,7 +1239,7 @@ public static TpSlots fromNative(PythonAbstractNativeObject pythonClass, PythonC
                         // PyObject_HashNotImplemented, we still assign it to the slot as wrapped
                         // native executable later on
                         if (CApiContext.isIdenticalToSymbol(fieldPointer, NativeCAPISymbol.FUN_PYOBJECT_HASH_NOT_IMPLEMENTED)) {
-                            builder.set(def, TpSlotIterNext.NEXT_NOT_IMPLEMENTED);
+                            builder.set(def, TpSlotHashFun.HASH_NOT_IMPLEMENTED);
                             continue;
                         }
                     } else if (def == TpSlotMeta.TP_ITERNEXT) {
@@ -1534,7 +1534,7 @@ private static Builder updateSlots(PythonAbstractClass klass, Builder slots, Set
                     // TODO: special cases:
                     // PyCFunction_Type && tp_new (looks like just optimization)
                 } else if (descr == PNone.NONE && slot == TpSlotMeta.TP_HASH) {
-                    specific = PyObjectHashNotImplemented.INSTANCE;
+                    specific = TpSlotHashFun.HASH_NOT_IMPLEMENTED;
                 } else {
                     useGeneric = true;
                     generic = defs[i].functionFactory;
@@ -1621,7 +1621,7 @@ public static void addOperatorsToBuiltin(Map<TruffleString, BoundBuiltinCallable
         for (var slotDefGroup : SLOTDEFS.entrySet()) {
             TpSlotMeta slotMeta = slotDefGroup.getKey();
             TpSlot slotValue = slotMeta.getter.get(slots);
-            if (slotMeta == TpSlotMeta.TP_HASH && slotValue == PyObjectHashNotImplemented.INSTANCE) {
+            if (slotMeta == TpSlotMeta.TP_HASH && slotValue == TpSlotHashFun.HASH_NOT_IMPLEMENTED) {
                 DynamicObjectLibrary.getUncached().put(pythonBuiltinClass, T___HASH__, PNone.NONE);
                 continue;
             }
@@ -1664,7 +1664,7 @@ public void addOperators(PythonClass type) {
                     continue;
                 }
                 Object wrapperDescriptor = null;
-                if (value == PyObjectHashNotImplemented.INSTANCE) {
+                if (value == TpSlotHashFun.HASH_NOT_IMPLEMENTED) {
                     wrapperDescriptor = PNone.NO_VALUE;
                 } else if (value instanceof TpSlotBuiltin<?> builtinSlot) {
                     wrapperDescriptor = builtinSlot.createBuiltin(context, type, tpSlotDef.name, tpSlotDef.wrapper);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TypeNodes.java

@@ -177,7 +177,7 @@
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.IsSameTypeNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.IsTypeNodeGen;
 import com.oracle.graal.python.builtins.objects.type.TypeNodesFactory.SetTypeFlagsNodeGen;
-import com.oracle.graal.python.builtins.objects.type.slots.PyObjectHashNotImplemented;
+import com.oracle.graal.python.builtins.objects.type.slots.TpSlotHashFun;
 import com.oracle.graal.python.lib.PyObjectSizeNode;
 import com.oracle.graal.python.lib.PyUnicodeCheckNode;
 import com.oracle.graal.python.nodes.ErrorMessages;
@@ -2027,7 +2027,7 @@ protected PythonClass makeType(VirtualFrame frame, PDict namespaceOrig, TruffleS
                 if (inheritedSlots.get(TpSlotMeta.TP_HASH) == null) {
                     Object dunderHash = getItemNamespace.execute(inliningTarget, namespace.getDictStorage(), T___HASH__);
                     if (dunderHash == null) {
-                        inheritedSlots.set(TpSlotMeta.TP_HASH, PyObjectHashNotImplemented.INSTANCE);
+                        inheritedSlots.set(TpSlotMeta.TP_HASH, TpSlotHashFun.HASH_NOT_IMPLEMENTED);
                         newType.setAttribute(T___HASH__, PNone.NONE);
                     }
                 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/slots/PyObjectHashNotImplemented.java

@@ -110,7 +110,7 @@ public static Object toNative(TpSlotMeta slotMeta, TpSlot slot, Object defaultVa
     }
 
     private static Object getNativeWrapper(TpSlotMeta slotMeta, TpSlotManaged slot) {
-        if (slot == PyObjectHashNotImplemented.INSTANCE) {
+        if (slot == TpSlotHashFun.HASH_NOT_IMPLEMENTED) {
             // If there are more such cases, we should add generic mapping mechanism
             // This translation other way around is also done in TpSlots.fromNative
             // We must not cache this in the singleton slot object, it would hold onto and leak

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/slots/TpSlot.java

@@ -52,10 +52,14 @@
 import com.oracle.graal.python.builtins.objects.cext.capi.transitions.CApiTransitions.PythonToNativeNode;
 import com.oracle.graal.python.builtins.objects.function.PArguments;
 import com.oracle.graal.python.builtins.objects.ints.IntBuiltins;
+import com.oracle.graal.python.builtins.objects.type.TpSlots.TpSlotMeta;
 import com.oracle.graal.python.builtins.objects.type.slots.PythonDispatchers.UnaryPythonSlotDispatcherNode;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotBuiltinBase;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotCExtNative;
+import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotManaged;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlot.TpSlotPythonSingle;
+import com.oracle.graal.python.builtins.objects.type.slots.TpSlotHashFun.PyObjectHashNotImplemented.HashNotImplementedNode;
+import com.oracle.graal.python.builtins.objects.type.slots.TpSlotHashFunFactory.PyObjectHashNotImplementedFactory.HashNotImplementedNodeFactory;
 import com.oracle.graal.python.lib.PyLongAsLongAndOverflowNode;
 import com.oracle.graal.python.lib.PyLongCheckNode;
 import com.oracle.graal.python.nodes.ErrorMessages;
@@ -74,6 +78,7 @@
 import com.oracle.truffle.api.dsl.Cached.Exclusive;
 import com.oracle.truffle.api.dsl.GenerateCached;
 import com.oracle.truffle.api.dsl.GenerateInline;
+import com.oracle.truffle.api.dsl.GenerateNodeFactory;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.NodeFactory;
 import com.oracle.truffle.api.dsl.Specialization;
@@ -83,9 +88,32 @@
 import com.oracle.truffle.api.profiles.InlinedConditionProfile;
 
 public abstract class TpSlotHashFun {
+    public static final TpSlotManaged HASH_NOT_IMPLEMENTED = new PyObjectHashNotImplemented();
+
     private TpSlotHashFun() {
     }
 
+    /**
+     * Mirror of the {@code PyObject_HashNotImplemented} slot on the managed side. We translate this
+     * slot singleton instance to a pointer to the {@code PyObject_HashNotImplemented} C function in
+     * {@link TpSlot#toNative(TpSlotMeta, TpSlot, Object)} and vice versa in
+     * {@code TpSlot#fromNative(PythonContext, Object, InteropLibrary)}.
+     */
+    public static class PyObjectHashNotImplemented extends TpSlotHashBuiltin<HashNotImplementedNode> {
+        private PyObjectHashNotImplemented() {
+            super(HashNotImplementedNodeFactory.getInstance());
+        }
+
+        @GenerateNodeFactory
+        public abstract static class HashNotImplementedNode extends HashBuiltinNode {
+            @Specialization
+            static long doIt(@SuppressWarnings("unused") Object obj,
+                            @Bind Node nodeForRaise) {
+                throw PRaiseNode.raiseStatic(nodeForRaise, PythonBuiltinClassType.TypeError, ErrorMessages.UNHASHABLE_TYPE_P, obj);
+            }
+        }
+    }
+
     public abstract static class TpSlotHashBuiltin<T extends HashBuiltinNode>
                     extends TpSlotBuiltinBase<T> {
         static final BuiltinSlotWrapperSignature SIGNATURE = BuiltinSlotWrapperSignature.UNARY;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/slots/TpSlotHashFun.java

@@ -70,7 +70,7 @@
  * referential equality first (when doing equality comparison) before calling the special method.
  * This makes a difference for objects that report they are unequal to themselves (i.e.
  * {@code NaN}). Since we do not maintain identity for unboxed float objects, we cannot fully match
- * the CPython behavior - we treat all NaNs as equal.
+ * the CPython behavior - we treat all NaNs with exactly the same bits as equal.
  */
 @GenerateInline
 @GenerateCached(false)