Ensure that Held arguments to entrypointed methods work correctly.

Author: braxtonmckee

typed_python/FunctionCallArgMapping.hpp

@@ -31,6 +31,50 @@ class FunctionCallArgMapping {
     FunctionCallArgMapping& operator=(const FunctionCallArgMapping&) = delete;
 
 public:
+    class FunctionArg {
+    public:
+        FunctionArg() :
+            mInstance(),
+            mValid(false),
+            mRawPtr(nullptr)
+        {
+        }
+
+        FunctionArg(instance_ptr inData) :
+            mInstance(),
+            mValid(true),
+            mRawPtr(inData)
+        {
+        }
+
+        FunctionArg(Instance i) :
+            mInstance(i),
+            mValid(true),
+            mRawPtr(nullptr)
+        {
+        }
+
+        bool isValid() const {
+            return mValid;
+        }
+
+        instance_ptr dataPtr() const {
+            if (mRawPtr) {
+                return mRawPtr;
+            }
+
+            return mInstance.data();
+        }
+
+    private:
+        bool mValid;
+
+        Instance mInstance;
+
+        instance_ptr mRawPtr;
+    };
+
+
     FunctionCallArgMapping(const Function::Overload& overload) :
             mArgs(overload.getArgs()),
             mCurrentArgumentIx(0),
@@ -331,36 +375,38 @@ class FunctionCallArgMapping {
         return res;
     }
 
-    std::pair<Instance, bool> extractArgWithType(int argIx, Type* argType) const {
+    FunctionArg extractArgWithType(int argIx, Type* argType) const {
         if (mArgs[argIx].getIsNormalArg()) {
             try {
                 Type* actualType = PyInstance::extractTypeFrom(mSingleValueArgs[argIx]->ob_type);
                 if (actualType == argType) {
                     // nothing to do!
                     PyInstance* argAsPyInstance = ((PyInstance*)mSingleValueArgs[argIx]);
 
-                    return std::make_pair(
-                        argAsPyInstance->mContainingInstance,
-                        true
+                    if (argAsPyInstance->mTemporaryRefTo) {
+                        return FunctionArg(argAsPyInstance->mTemporaryRefTo);
+                    }
+
+                    return FunctionArg(
+                        argAsPyInstance->mContainingInstance
                     );
                 }
 
-                return std::make_pair(
+                return FunctionArg(
                     Instance::createAndInitialize(argType, [&](instance_ptr p) {
                         PyInstance::copyConstructFromPythonInstance(
                             argType, p, mSingleValueArgs[argIx], ConversionLevel::Signature
                         );
-                    }),
-                    true
+                    })
                 );
             } catch(PythonExceptionSet& s) {
                 // failed to convert, but keep going
                 PyErr_Clear();
-                return std::pair<Instance, bool>(Instance(), false);
+                return FunctionArg();
             }
             catch(...) {
                 // not a valid conversion
-                return std::pair<Instance, bool>(Instance(), false);
+                return FunctionArg();
             }
         } else if (mArgs[argIx].getIsStarArg()) {
             if (argType->getTypeCategory() != Type::TypeCategory::catTuple) {
@@ -370,29 +416,28 @@ class FunctionCallArgMapping {
             Tuple* tup = (Tuple*)argType;
 
             if (mStarArgValues.size() != tup->getTypes().size()) {
-                return std::pair<Instance, bool>(Instance(), false);
+                return FunctionArg();
             }
 
             try {
-                return std::make_pair(
+                return FunctionArg(
                     Instance::createAndInitialize(tup, [&](instance_ptr p) {
                         tup->constructor(p, [&](instance_ptr subElt, int tupArg) {
                             PyInstance::copyConstructFromPythonInstance(
                                 tup->getTypes()[tupArg], subElt, mStarArgValues[tupArg],
                                 ConversionLevel::Signature
                             );
                         });
-                    }),
-                    true
+                    })
                 );
             } catch(PythonExceptionSet& s) {
                 // failed to convert, but keep going
                 PyErr_Clear();
-                return std::pair<Instance, bool>(Instance(), false);
+                return FunctionArg();
             }
             catch(...) {
                 // not a valid conversion
-                return std::pair<Instance, bool>(Instance(), false);
+                return FunctionArg();
             }
         } else if (mArgs[argIx].getIsKwarg()) {
             if (argType->getTypeCategory() != Type::TypeCategory::catNamedTuple) {
@@ -402,17 +447,17 @@ class FunctionCallArgMapping {
             NamedTuple* tup = (NamedTuple*)argType;
 
             if (mKwargValues.size() != tup->getTypes().size()) {
-                return std::pair<Instance, bool>(Instance(), false);
+                return FunctionArg();
             }
 
             for (long k = 0; k < mKwargValues.size(); k++) {
                 if (mKwargValues[k].first != tup->getNames()[k]) {
-                    return std::pair<Instance, bool>(Instance(), false);
+                    return FunctionArg();
                 }
             }
 
             try {
-                return std::make_pair(
+                return FunctionArg(
                     Instance::createAndInitialize(tup, [&](instance_ptr p) {
                         tup->constructor(p, [&](instance_ptr subElt, int tupArg) {
                             PyInstance::copyConstructFromPythonInstance(
@@ -422,17 +467,16 @@ class FunctionCallArgMapping {
                                 ConversionLevel::Signature
                             );
                         });
-                    }),
-                    true
+                    })
                 );
             } catch(PythonExceptionSet& s) {
                 // failed to convert, but keep going
                 PyErr_Clear();
-                return std::pair<Instance, bool>(Instance(), false);
+                return FunctionArg();
             }
             catch(...) {
                 // not a valid conversion
-                return std::pair<Instance, bool>(Instance(), false);
+                return FunctionArg();
             }
         }
 

typed_python/PyFunctionInstance.cpp

@@ -514,7 +514,7 @@ std::pair<bool, PyObject*> PyFunctionInstance::dispatchFunctionCallToCompiledSpe
         throw std::runtime_error("Malformed function specialization: missing a return type.");
     }
 
-    std::vector<Instance> instances;
+    std::vector<FunctionCallArgMapping::FunctionArg> mappingArgs;
 
     // first, see if we can short-circuit
     for (long k = 0; k < overload.getArgs().size(); k++) {
@@ -532,10 +532,10 @@ std::pair<bool, PyObject*> PyFunctionInstance::dispatchFunctionCallToCompiledSpe
         auto arg = overload.getArgs()[k];
         Type* argType = specialization.getArgTypes()[k];
 
-        std::pair<Instance, bool> res = mapper.extractArgWithType(k, argType);
+        FunctionCallArgMapping::FunctionArg res = mapper.extractArgWithType(k, argType);
 
-        if (res.second) {
-            instances.push_back(res.first);
+        if (res.isValid()) {
+            mappingArgs.push_back(res);
         } else {
             return std::pair<bool, PyObject*>(false, (PyObject*)nullptr);
         }
@@ -552,8 +552,8 @@ std::pair<bool, PyObject*> PyFunctionInstance::dispatchFunctionCallToCompiledSpe
             args.push_back(closureCells.back().data());
         }
 
-        for (auto& i: instances) {
-            args.push_back(i.data());
+        for (auto& i: mappingArgs) {
+            args.push_back(i.dataPtr());
         }
 
         auto functionPtr = specialization.getFuncPtr();

typed_python/compiler/tests/class_compilation_test.py

@@ -366,6 +366,19 @@ def callStr(x):
         self.assertEqual(callRepr(ClassWithReprAndStr()), "repr")
         self.assertEqual(callStr(ClassWithReprAndStr()), "str")
 
+    def test_class_str_without_override(self):
+        class NoStr(Class):
+            x = Member(int)
+            y = Member(float)
+
+        @Entrypoint
+        def callStr(x):
+            return str(x)
+
+        n = NoStr()
+
+        assert str(n) == callStr(n)
+
     def test_compiled_class_subclass_layout(self):
         class BaseClass(Class):
             x = Member(int)

typed_python/compiler/tests/held_class_compilation_test.py

@@ -1,13 +1,13 @@
 import unittest
 import time
 from typed_python import _types
-from typed_python import Class, Final, ListOf, Held, Member, Entrypoint, Forward
+from typed_python import Class, Final, ListOf, Held, Member, Entrypoint, Forward, pointerTo
 
 
 @Held
 class H(Class, Final):
-    x = Member(int)
-    y = Member(float)
+    x = Member(int, nonempty=True)
+    y = Member(float, nonempty=True)
 
     def f(self):
         return self.x + self.y
@@ -21,6 +21,14 @@ def entrypointedIncrement(self):
         self.x += 1
         self.y += 1
 
+    @Entrypoint
+    def getX(self):
+        return self.x
+
+    @Entrypoint
+    def pointerToSelf(self):
+        return pointerTo(self)
+
 
 Complex = Forward("Complex")
 
@@ -55,14 +63,43 @@ def checkCompiler(self, f, *args, **kwargs):
 
         self.assertEqual(compiledOutput, interpretedOutput)
 
+    def test_held_class_pointer_to_self(self):
+        @Entrypoint
+        def callPointerTo(h):
+            return pointerTo(h)
+
+        h = H(x=2, y=3)
+
+        assert callPointerTo(h) == pointerTo(h)
+        assert h.pointerToSelf() == pointerTo(h)
+
     def test_held_class_entrypointed_methods(self):
-        h1 = H()
-        h2 = H()
+        h1 = H(x=2, y=3)
+        h2 = H(x=2, y=3)
 
         h1.entrypointedIncrement()
         h2.increment()
 
         assert h1.x == h2.x
+        assert h1.getX() == h1.x
+
+    def test_stringify_held_class(self):
+        h = H(x=2, y=3)
+
+        @Entrypoint
+        def callStr(h):
+            return str(h)
+
+        assert str(h) == callStr(h)
+
+    def test_pointer_to_held_class_compiles(self):
+        h = H(x=2, y=3)
+
+        @Entrypoint
+        def getPtr(h):
+            return pointerTo(h)
+
+        assert pointerTo(h) == getPtr(h)
 
     def test_pass_held_to_function_with_signature(self):
         @Entrypoint

typed_python/compiler/type_wrappers/held_class_wrapper.py

@@ -20,7 +20,7 @@
     ClassOrAlternativeWrapperMixin
 )
 
-from typed_python import _types, RefTo
+from typed_python import _types, RefTo, PointerTo
 
 import typed_python.compiler.native_ast as native_ast
 import typed_python.compiler
@@ -40,6 +40,7 @@ def __init__(self, t):
         self.heldClassType = t
         self.classType = t.Class
         self.refToType = RefTo(t)
+        self.ptrToType = PointerTo(t)
 
         self.classTypeWrapper = typeWrapper(t.Class)
         self.nameToIndex = self.classTypeWrapper.nameToIndex
@@ -58,6 +59,10 @@ def __init__(self, t):
             count=_types.bytecount(self.heldClassType)
         )
 
+    def convert_pointerTo(self, context, instance):
+        assert instance.isReference
+        return instance.changeType(self.ptrToType, isReferenceOverride=False)
+
     def fieldGuaranteedInitialized(self, ix):
         if self.classType.ClassMembers[
             self.classType.MemberNames[ix]
@@ -87,13 +92,12 @@ def convert_attribute_pointerTo(self, context, pointerInstance, attribute):
         return super().convert_attribute(context, pointerInstance, attribute)
 
     def _can_convert_to_type(self, otherType, explicit):
-        return False
+        return super()._can_convert_to_type(otherType, explicit)
 
     def _can_convert_from_type(self, otherType, explicit):
-        return False
+        return super()._can_convert_from_type(otherType, explicit)
 
     def convert_to_type_with_target(self, context, instance, targetVal, conversionLevel, mayThrowOnFailure=False):
-        print("Converting held class ", self, " to ", targetVal)
         return super().convert_to_type_with_target(context, instance, targetVal, conversionLevel, mayThrowOnFailure)
 
     def bytesOfInitBitsForInstance(self, instance):