Ensure that we don't arbitrarily duplicate HeldClass instances when calling functions.

In general, we want to ensure that if we pass a held class into a function, and
that held class has a clear storage owner in the parent context, that we pass
a reference to it into the function, so that we can modify the instance.

For that to work, we need to not be making a bunch of copies of it.

Author: braxtonmckee

typed_python/FunctionCallArgMapping.hpp

@@ -47,6 +47,12 @@ class FunctionCallArgMapping {
 
     void coerceToType(py_obj_ptr& ptr, Type* target, ConversionLevel level) {
         try {
+            Type* actualType = PyInstance::extractTypeFrom(ptr->ob_type);
+            if (actualType == target) {
+                // nothing to do!
+                return;
+            }
+
             PyObject* coerced = PyInstance::initializePythonRepresentation(
                 target,
                 [&](instance_ptr data) {
@@ -328,6 +334,17 @@ class FunctionCallArgMapping {
     std::pair<Instance, bool> 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
+                    );
+                }
+
                 return std::make_pair(
                     Instance::createAndInitialize(argType, [&](instance_ptr p) {
                         PyInstance::copyConstructFromPythonInstance(

typed_python/compiler/tests/held_class_compilation_test.py

@@ -16,6 +16,11 @@ def increment(self):
         self.x += 1
         self.y += 1
 
+    @Entrypoint
+    def entrypointedIncrement(self):
+        self.x += 1
+        self.y += 1
+
 
 Complex = Forward("Complex")
 
@@ -50,6 +55,37 @@ def checkCompiler(self, f, *args, **kwargs):
 
         self.assertEqual(compiledOutput, interpretedOutput)
 
+    def test_held_class_entrypointed_methods(self):
+        h1 = H()
+        h2 = H()
+
+        h1.entrypointedIncrement()
+        h2.increment()
+
+        assert h1.x == h2.x
+
+    def test_pass_held_to_function_with_signature(self):
+        @Entrypoint
+        def f(h: H):
+            h.x = 100
+
+        @Entrypoint
+        def g():
+            h = H()
+            f(h)
+            return h
+
+        assert g().x == 100
+
+    def test_pass_held_by_ref_across_entrypoint(self):
+        @Entrypoint
+        def g(h):
+            h.x = 100
+
+        h = H()
+        g(h)
+        assert h.x == 100
+
     def test_compile_held_class(self):
         @Held
         class H(Class, Final):

typed_python/compiler/tests/held_class_interpreter_semantics_test.py

@@ -166,6 +166,15 @@ def g(l):
 
         runTest()
 
+    def testPassHeldClassToTypedArg(self):
+        @Function
+        def f(h: H):
+            h.x = 100
+
+        h = H()
+        f(h)
+        assert h.x == 100
+
     def testCallBoundMethodOnLeakedTemporaryCrashes(self):
         with self.assertRaisesRegex(Exception, "would have crashed"):
             def runTest():

typed_python/compiler/type_wrappers/held_class_wrapper.py

@@ -92,6 +92,10 @@ def _can_convert_to_type(self, otherType, explicit):
     def _can_convert_from_type(self, otherType, explicit):
         return False
 
+    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):
         return native_ast.const_uint64_expr(self.bytesOfInitBits)