Ensure that HeldClass honors __str__ and __repr__

Author: braxtonmckee

typed_python/ClassType.cpp

@@ -157,7 +157,6 @@ void Class::repr(instance_ptr self, ReprAccumulator& stream, bool isStr) {
             );
     }
 
-
     layout& l = *instanceToLayout(self);
     m_heldClass->repr(l.data, stream, isStr, true /* isClassNotHeldClass */);
 }

typed_python/HeldClassType.cpp

@@ -87,6 +87,42 @@ bool HeldClass::cmp(instance_ptr left, instance_ptr right, int pyComparisonOp, b
 }
 
 void HeldClass::repr(instance_ptr self, ReprAccumulator& stream, bool isStr, bool isClassNotHeldClass) {
+    auto it = getMemberFunctions().find(isStr ? "__str__" : "__repr__");
+
+    if (it != getMemberFunctions().end()) {
+        PyEnsureGilAcquired acquireTheGil;
+
+        PyObjectStealer selfAsPyObj(PyInstance::extractPythonObject(self, this));
+
+        std::pair<bool, PyObject*> res = PyFunctionInstance::tryToCall(
+            it->second,
+            nullptr,
+            selfAsPyObj
+        );
+
+        if (res.first) {
+            if (!res.second) {
+                throw PythonExceptionSet();
+            }
+            if (!PyUnicode_Check(res.second)) {
+                decref(res.second);
+                throw std::runtime_error(
+                    stream.isStrCall() ? "__str__ returned a non-string" : "__repr__ returned a non-string"
+                    );
+            }
+
+            stream << PyUnicode_AsUTF8(res.second);
+            decref(res.second);
+
+            return;
+        }
+
+        throw std::runtime_error(
+            stream.isStrCall() ? "Found a __str__ method but failed to call it with 'self'"
+                : "Found a __repr__ method but failed to call it with 'self'"
+            );
+    }
+
     PushReprState isNew(stream, self);
 
     std::string name = isClassNotHeldClass ? getClassType()->name() : m_name;

typed_python/compiler/tests/held_class_compilation_test.py

@@ -29,6 +29,12 @@ def getX(self):
     def pointerToSelf(self):
         return pointerTo(self)
 
+    def __repr__(self):
+        return "ReprForH"
+
+    def __str__(self):
+        return "StrForH"
+
 
 Complex = Forward("Complex")
 
@@ -73,6 +79,14 @@ def callPointerTo(h):
         assert callPointerTo(h) == pointerTo(h)
         assert h.pointerToSelf() == pointerTo(h)
 
+    def test_held_class_repr(self):
+        assert repr(H()) == "ReprForH"
+        self.checkCompiler(lambda x: repr(x), H())
+
+    def test_held_class_str(self):
+        assert str(H()) == "StrForH"
+        self.checkCompiler(lambda x: str(x), H())
+
     def test_held_class_entrypointed_methods(self):
         h1 = H(x=2, y=3)
         h2 = H(x=2, y=3)

typed_python/compiler/tests/held_class_interpreter_semantics_test.py

@@ -25,6 +25,14 @@ def increment(self):
 
 
 class TestHeldClassInterpreterSemantics(unittest.TestCase):
+    def test_held_class_str(self):
+        @Held
+        class H(Class):
+            def __str__(self):
+                return "HI"
+
+        assert str(H()) == "HI"
+
     def test_can_return_held_class_from_typed_function(self):
         @Function
         def f(x, y) -> H: