Ensure that if 'A' is an alternative with X as a choice, that Set(A.X) works correctly.

Author: braxtonmckee

typed_python/AlternativeType.cpp

@@ -123,35 +123,6 @@ bool Alternative::cmp(instance_ptr left, instance_ptr right, int pyComparisonOp,
     return m_subtypes[record_l.which].second->cmp(record_l.data, record_r.data, pyComparisonOp, suppressExceptions);
 }
 
-//static
-bool Alternative::cmpStatic(Alternative* altT, instance_ptr left, instance_ptr right, int64_t pyComparisonOp) {
-    if (altT->m_all_alternatives_empty) {
-        if (*(uint8_t*)left < *(uint8_t*)right) {
-            return cmpResultToBoolForPyOrdering(pyComparisonOp, -1);
-        }
-        if (*(uint8_t*)left > *(uint8_t*)right) {
-            return cmpResultToBoolForPyOrdering(pyComparisonOp, 1);
-        }
-        return cmpResultToBoolForPyOrdering(pyComparisonOp, 0);
-    }
-
-    layout& record_l = **(layout**)left;
-    layout& record_r = **(layout**)right;
-
-    if ( &record_l == &record_r ) {
-        return cmpResultToBoolForPyOrdering(pyComparisonOp, 0);
-    }
-
-    if (record_l.which < record_r.which) {
-        return cmpResultToBoolForPyOrdering(pyComparisonOp, -1);
-    }
-    if (record_l.which > record_r.which) {
-        return cmpResultToBoolForPyOrdering(pyComparisonOp, 1);
-    }
-
-    return altT->m_subtypes[record_l.which].second->cmp(record_l.data, record_r.data, pyComparisonOp, false);
-}
-
 void Alternative::repr(instance_ptr self, ReprAccumulator& stream, bool isStr) {
     PushReprState isNew(stream, self);
 

typed_python/AlternativeType.hpp

@@ -182,9 +182,7 @@ class Alternative : public Type {
         }
     }
 
-
     bool cmp(instance_ptr left, instance_ptr right, int pyComparisonOp, bool suppressExceptions);
-    static bool cmpStatic(Alternative* altT, instance_ptr left, instance_ptr right, int64_t pyComparisonOp);
 
     template<class buf_t>
     void serialize(instance_ptr self, buf_t& buffer, size_t fieldNumber) {

typed_python/ConcreteAlternativeType.hpp

@@ -103,7 +103,7 @@ class ConcreteAlternative : public Type {
     }
 
     bool cmp(instance_ptr left, instance_ptr right, int pyComparisonOp, bool suppressExceptions) {
-        return m_alternative->cmp(left,right, pyComparisonOp, suppressExceptions);
+        return m_alternative->cmp(left, right, pyComparisonOp, suppressExceptions);
     }
 
     void constructor(instance_ptr self);

typed_python/_runtime.cpp

@@ -466,13 +466,15 @@ extern "C" {
         return StringType::cmpStatic(lhs, rhs);
     }
 
-    bool np_runtime_alternative_cmp(Alternative* tp, instance_ptr lhs, instance_ptr rhs, int64_t pyComparisonOp) {
-        return Alternative::cmpStatic(tp, lhs, rhs, pyComparisonOp);
-    }
+    bool np_instance_cmp(Type* t, instance_ptr lhs, instance_ptr rhs, int64_t pyComparisonOp) {
+        try {
+            return t->cmp(lhs, rhs, pyComparisonOp, false);
+        } catch(std::exception& e) {
+            PyEnsureGilAcquired getTheGil;
 
-    bool np_runtime_class_cmp(Class* tp, instance_ptr lhs, instance_ptr rhs, int64_t pyComparisonOp) {
-        PyEnsureGilAcquired acquireTheGil;
-        return Class::cmpStatic(tp, lhs, rhs, pyComparisonOp);
+            PyErr_SetString(PyExc_TypeError, e.what());
+            throw PythonExceptionSet();
+        }
     }
 
     StringType::layout* np_typePtrToName(Type* t) {

typed_python/compiler/tests/alternative_compilation_test.py

@@ -24,6 +24,7 @@
 import psutil
 from math import trunc, floor, ceil
 from typed_python.compiler.type_wrappers.class_wrapper import classCouldBeInstanceOf
+from typed_python.compiler.type_wrappers.hash_table_implementation import NativeHash
 
 
 class TestAlternativeCompilation(unittest.TestCase):
@@ -1724,3 +1725,32 @@ def g(x: A):
             return f(x)
 
         assert g(A.X(x=10)) == 10
+
+    def test_alternative_hashing(self):
+        A = Alternative("A", A=dict(a=int))
+
+        assert NativeHash.callHash(A.A, A.A(a=12)) == hash(A.A(a=12))
+        assert NativeHash.callHash(A, A.A(a=12)) == hash(A.A(a=12))
+
+    def test_alternative_equality(self):
+        AB = Alternative("AB", A=dict(a=int), B=dict(b=str))
+
+        @Entrypoint
+        def eqConcrete(a1: AB.A, a2: AB.A):
+            return a1 == a2
+
+        @Entrypoint
+        def eqMixed(a1: AB, a2: AB.A):
+            return a1 == a2
+
+        @Entrypoint
+        def eq(a1: AB, a2: AB):
+            return a1 == a2
+
+        assert not eq(AB.A(a=1), AB.A(a=2))
+        assert not eqMixed(AB.A(a=1), AB.A(a=2))
+        assert not eqConcrete(AB.A(a=1), AB.A(a=2))
+
+        assert eq(AB.A(a=1), AB.A(a=1))
+        assert eqMixed(AB.A(a=1), AB.A(a=1))
+        assert eqConcrete(AB.A(a=1), AB.A(a=1))

typed_python/compiler/tests/set_compilation_test.py

@@ -14,7 +14,7 @@
 
 from typed_python import (
     Set, ListOf, Entrypoint, Compiled, Tuple, TupleOf, NamedTuple, Dict, ConstDict, OneOf,
-    UInt8
+    UInt8, Alternative
 )
 from typed_python.compiler.type_wrappers.set_wrapper import (
     set_union, set_intersection, set_difference,
@@ -1191,3 +1191,28 @@ def callC(y: OneOf(None, Set(float))):
             return C(y)
 
         callC([1])
+
+    def test_set_of_specific_alternative(self):
+        A = Alternative(
+            "A",
+            A=dict(a=int),
+            B=dict(b=str),
+        )
+
+        s = Set(A.A)()
+
+        @Entrypoint
+        def add(s, k):
+            s.add(k)
+
+        @Entrypoint
+        def contains(s, k):
+            return k in s
+
+        someInts = [1, 10, 2, 6, 123, 13]
+
+        for i in someInts:
+            add(s, A.A(a=i))
+            assert A.A(a=i) in s
+            assert contains(s, A.A(a=i))
+            assert not contains(s, A.A(a=-i))

typed_python/compiler/type_wrappers/alternative_wrapper.py

@@ -61,16 +61,13 @@ def convert_comparison(self, context, lhs, op, rhs):
         if py_code < 0:
             return super().convert_comparison(context, lhs, op, rhs)
 
-        if not lhs.isReference:
-            lhs = context.pushMove(lhs)
+        if _types.isBinaryCompatible(lhs.expr_type.typeRepresentation, rhs.expr_type.typeRepresentation):
+            lhs = lhs.ensureIsReference()
+            rhs = rhs.ensureIsReference()
 
-        if not rhs.isReference:
-            rhs = context.pushMove(rhs)
-
-        if lhs.expr_type.typeRepresentation == rhs.expr_type.typeRepresentation:
             return context.pushPod(
                 bool,
-                runtime_functions.alternative_cmp.call(
+                runtime_functions.instance_cmp.call(
                     context.getTypePointer(lhs.expr_type.typeRepresentation),
                     lhs.expr.cast(VoidPtr),
                     rhs.expr.cast(VoidPtr),

typed_python/compiler/type_wrappers/hash_table_implementation.py

@@ -77,6 +77,16 @@ def convert_call(self, context, instance, args, kwargs):
 
         return super().convert_call(context, instance, args, kwargs)
 
+    @staticmethod
+    def callHash(T, x):
+        from typed_python import Entrypoint
+
+        @Entrypoint
+        def hashIt(x):
+            return NativeHash(T)(x)
+
+        return hashIt(x)
+
 
 def table_add_slot(instance, itemHash, slot):
     if (instance._hash_table_count * 2 + 1 > instance._hash_table_size or

typed_python/compiler/type_wrappers/runtime_functions.py

@@ -526,18 +526,12 @@ def unaryPyobjCallTarget(name, retType=Void.pointer()):
     Void.pointer(), Void.pointer()
 )
 
-alternative_cmp = externalCallTarget(
-    "np_runtime_alternative_cmp",
+instance_cmp = externalCallTarget(
+    "np_instance_cmp",
     Bool,
     Void.pointer(), Void.pointer(), Void.Pointer(), Int64
 )
 
-class_cmp = externalCallTarget(
-    "np_runtime_class_cmp",
-    Bool,
-    UInt64, Void.pointer(), Void.Pointer(), Int64
-)
-
 string_chr_int64 = externalCallTarget(
     "nativepython_runtime_string_chr",
     Void.pointer(),